public class CalculatorServer {
  public static void main(String[] args) {
    
    try (ServerSocket serverSocket = new ServerSocket(80)) {
      System.out.println("서버 실행 중...");
      
      while (true) {
        RequestProcessor thread = new RequestProcessor(serverSocket.accept());
        thread.start();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

// HTTP 요청 프로토콜
// ---------------------------------
// GET [자원주소] HTTP/1.1 (CRLF)
// Host: [서버주소] (CRLF)
// (CRLF)
// ---------------------------------

public class RequestProcessor extends Thread {
  Socket socket;

  public RequestProcessor(Socket socket) {
    this.socket = socket;
  }

  @Override
  public void run() {
    try (Socket socket = this.socket;
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintStream out = new PrintStream(socket.getOutputStream());) {
      // 웹 브라우저가 보낸 첫 줄에는 데이터가 포함되어 있기 때문에 따로 추출
      String requestLine = in.readLine();
      
      // 나머지 요청과 관련된 헤더 정보(부가 정보)는 현재 사용할 일이 없기 때문에 버림
      while (true) {
        if (in.readLine().length() == 0)
          break;
      }
      
      sendHttpResponse(out, compute(requestLine)); 
      
    } catch (Exception e) {
      System.out.printf("클라이언트 요청 처리 중 오류 발생! - %s\n", e.getMessage());
    }
  }

  private String compute(String request) {
    try {
      // 웹 브라우저가 보낸 request line에서 데이터를 추출한다.
      // 예) "GET /plus?a=100&b=200 HTTP/1.1"
      String[] values = request.split(" ")[1].split("\\?"); //["/plus", "a=100&b=200", "HTTP/1.1"]
      
      String op = getOperator(values[0]); // "/plus", "/multiple" 등
      
      String[] parameters = values[1].split("&"); //"a=100&b=200" => ["a=100", "b=200"]

      int a = 0;
      int b = 0;
      
      for (String parameter : parameters) {
        String[] kv = parameter.split("=");
        if (kv[0].equals("a"))
          a = Integer.parseInt(kv[0]);
        else if (kv[1].equals("b"))
          b = Integer.parseInt(kv[1]);
      }
      
      int result = 0;

      switch (op) {
        case "+": result = a + b; break;
        case "-": result = a - b; break;
        case "*": result = a * b; break;
        case "/": result = a / b; break;
        default:
          return "해당 연산자를 지원하지 않습니다.";
      }
      return String.format("결과는 %d %s %d = %d 입니다.", a, op, b, result);

    } catch (Exception e) {
      return String.format("계산 중 오류 발생! - %s", e.getMessage());
    }
  }
                   
  private String getOperator(String name) {
    switch(name) {
      case "/plus": return "+"; 
      case "/minus": return "-";
      case "/multiple": return "*";
      case "/devide": return "/";
      default: return "?";
    }
  }

  private void sendHttpResponse(PrintStream out, String message) {
    // HTTP 응답 형식에 맞춰 출력한다.
    out.println("HTTP/1.1 200 OK");
    out.println("Content-Type: text/plain;charset=UTF-8");
    out.println();
    out.println(message);
    out.flush();
  }
}

String requestLine = "GET /plus?a=100&b=200 HTTP/1.1";
String[] values = requestLine.split(" ")[1].split("\\?")[1].split("&");

for (String value : values)
  System.out.println(value);

public class ChatClient extends Frame implements ActionListener {
  private static final long serialVersion = 1L;
  
  TextField addressTF = new TextField(20);
  TextField portTF = new TextField(4);
  Button connectBtn = new Button("연결");
  TextArea chattingPane = new TextArea();
  Button sendBtn = new Button("보내기");
  
  Socket socket;
  BufferedReader in;
  PrintStream out;
  
  public ChatClient(String title) {
    super(title);
    this.setSize(600, 480);
    
      // 윈도우 관련 이벤트를 처리할 담당자를 설정한다.
    // => 옵저버 패턴
    // => 윈도우 이벤트가 발생했을 때 보고를 받을 객체를 등록한다.
    this.addWindowsListener(new WindowAdapter() {
      @Override
      public void windowClosing(WindowEvent e) {
        try {
          in.close();
        } catch (Exception ex) {

        }
        try {
          out.close();
        } catch (Exception ex) {

        }
        try {
          socket.close();
        } catch (Exception ex) {

        }
        System.exit(0);
      }
    });

    Panel topPane = new Panel();
    topPane.add(addressTF);
    topPane.add(portTF);
    topPane.add(connectBtn);
    this.add(topPane, BorderLayout.NORTH);

    this.add(chattingPane, BorderLayout.CENTER);

    Panel bottomPane = new Panel();
    bottomPane.setLayout(new BorderLayout());
    bottomPane.add(messageTF, BorderLayout.CENTER);
    bottomPane.add(sendBtn, BorderLayout.EAST);

    this.add(bottomPane, BorderLayout.SOUTH);

    // 연결 버튼에 대해 옵저버(리스너) 등록하기
    connectBtn.addActionListener(this);

    // 보내기 버튼에 대해 옵저버(리스너) 등록하기
    sendBtn.addActionListener(this);
  }
  
  @Override
  public void actionPerformed(ActionEvent e) {
    if (e.getSource() == sendBtn) {
      // 서버에 전송
      out.println(messageTF.getText());
      
      // 기존에 입력한 메시지는 지운다.
      messageTF.setText("");
    } else if (e.getSource() == connectBtn) {
      connectChatServer();
    }
  }
  
  private void connectChatServer() {
    try {
      socket = new Socket(addressTF.getText(), Integer.parseInt(portTF.getText()));
      out = new PrintStream(socket.getOutputStream());
      in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
      
      chattingPane.append("서버와 연결됨!\n");
      
      // 서버와 연결되면 메시지 수신을 별도의 담당자에게 맡긴다.
      new Thread(new MessageReceiver()).start();
      
      // 메시지 전송은 버튼을 누를 때마다 main 스레드가 처리할 것이다.
    } catch (Exception e) {
      chattingPane.append("서버 연결 오류!\n");
    }
  }
  
  class MessageReceiver implements Runnable {
    @Override
    public void run() {
      try {
        while (true) {
          String message = in.readLine();
          chattingPane.append(message + "\n");
        }
      } catch (Exception e) {
        chattingPane.append("메시지 수신 중 오류 발생!\n");
      }
    }
  }
  
  public static void main(String[] args) {
    ChatClient app = new ChatClient("비트 채팅!");
    app.setVisible(true);
  }
}

public class ChatServer {
  
  ArrayList<PrintStream> outputStreams = new ArrayList<>();
  
  int port;
  
  public ChatServer(int port) {
    this.port = port;
  }
  
  public void service() {
    try (ServerSocket serverSocket = new ServerSocket(port)) {
      System.out.println("채팅 서버 시작!");
      
      while (true) {
        new Thread(new ChatAgent(serverSocket.accept())).start();
        System.out.println("채팅 클라이언트가 연결되었음!");
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  
  synchronized private void send(String message) {
    for (PrintStream out : outputStreams) {
      try {
        out.println(message);
      } catch (Exception e) {
        // 출력이 안 되는 스트림은 다음에 사용하지 않기 위해 목록에서 제거한다.
        outputStreams.remove(out);
      }
    }
  }
  
  class ChatAgent implements Runnable {
    
    Socket socket;
    
    public ChatAgent(Socket socket) {
      this.socket = socket;
    }
    
    @Override
    public void run() {
      try (Socket socket = this.socket;
          BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
          PrintStream out = new PrintStream(socket.getOutputStream())) {
        
        // 출력 스트림을 ChatServer에 보관한다.
        outputStreams.add(out);
        
        while (true) {
          String message = in.readLine();
          if (message.equals("quit"))
            break;
          
          // 채팅 방에 참여한 모든 사람들에게 메시지를 전달한다.
          // => 메시지를 전문적으로 보내는 일을 하는 객체에 맡긴다.
          new Thread(new MessageSender(message)).start();
        }
        
        // 채팅 방에 참여한 모든 사람들에게 퇴장 메시지를 전달한다.
      } catch (Exception e) {
        e.printStackTrace();
      }
      System.out.println("채팅 클라이언트가 종료되었음!");
    }
  }
  
  class MessageSender implements Runnable {
    String message;
    
    public MessageSender(String message) {
      this.message = message;
    }
    
    @Override
    public void run() {
      send(message);
    }
  }
  
  public static void main(String[] args) {
    ChatServer chatServer = new ChatServer(8888);
    chatServer.service();
  }
}

public class Exam0120 {
  static class MyThread extends Thread {
    @Override
    public void run() {
      for (int i = 0; i < 1000; i++) {
        System.out.println("==> " + i);
      }
    }
  }
  
  public static void main(String[] args) {
    new MyThread().start();
    for (int i = 0; i < 1000; i++)
      System.out.println(">>>" + i);
  }
}

// 멀티 스레드 적용 전
public class Exam0110 {
  public static void main(String[] args) {
    for (int i = 0; i < 1000; i++)
      System.out.println("==>" + i);
    
    for (int i = 0; i < 1000; i++)
      System.out.println(">>>" + i);
  }
}

public class Exam0120 {
  static class MyThread extends Thread {
    @Override
    public void run() {
      for (int i = 0; i< 1000; i++)
        System.out.println("==> " + i);
    }
  }
  
  public static main(String[] args) {
    new MyThread().start();
    
    for (int i = 0; i < 1000; i++)
      System.out.println("==> " + i);
  }
}

public static void main(String[] args) {
  Thread mainThread = Thread.currentThread();
  ThreadGroup mainGroup = mainThread.getThreadGroup();
  ThreadGroup systemGroup = mainGroup.getParent();
  
  printThreads(systemGroup, "");
}

static void printThreads(ThreadGroup tg, String indent) {
  System.out.println(indent + tg.getName() + "(TG)");
  
  // 현재 스레드 그룹에 소속된 클래스를 출력하기
  Thread[] threads = new Thread[10];
  // 불린 값은 recursive 여부, 즉 하위 스레드 그룹까지 찾아들어갈 것인지
  int size = tg.enumerate(threads, false);
  for (int i = 0; i < size; i++)
    System.out.println(indent + "  ==> " + threads[i].getName() + "(T)");
  
  ThreadGroup[] groups = new ThreadGroup[10];
  int size = tg.enumerate(groups, false); 
  for (int i = 0; i < size; i++)
    printThreads(groups[i], indent + "  ");
  
}

/*
실행 결과
JVM의 스레드 계층도: (openjdk 8 기준)

system(TG)
  ==> Reference Handler(T)
  ==> Finalizer(T)
  ==> Signal Dispatcher(T)
  ==> Attach Listener(T)
  main(TG)
    ==> main(T)
*/

public class Exam0110 {
  class MyThread extends Thread {
    @Override
    public void run() {
      // 별도로 분리해서 병행으로 실행할 코드를 두는 것
      for (int i = 0; i < 1000; i++)
        System.out.println("===> " + i);
    }
  }
  
  // 스레드 실행
  // => Thread의 서브 클래스는 그냥 인스턴스를 만들어 start()을 호출한다.
  MyThread t = new MyThread();
  t.start(); // 실행 흐름을 분리한 후 즉시 리턴한다. 비동기로 동작한다.
}

public class Exam0120 {
  public static void main(String[] args) {
    new Thread() {
      @Override
      public void run() {
        for (int i = 0; i < 1000; i++)
          System.out.println("===> " + i);
      }
    }.start();
    
    for (int i = 0; i < 1000; i++)
      System.out.println(">>> " + i);
  }
}

public class Exoam0210 {
  public class void main(String[] args) {
    class MyRunnable implements Runnable {
      @Override
      public void run() {
        for (int i = 0; i < 1000; i++)
          System.out.println("===>" + i);
      }
    }
    
    // 스레드 실행하기
    // => Runnable 구현체를 Thread 객체에 실어서 실행한다.
    // => start()을 호출하여 기존 스레드에서 분리하여 스레드를 실행시킨다.
    Thread t = new Thread(new MyRunnable());
    t.start(); // 실행 흐름을 분리한 후 즉시 리턴
    
    // "main"스레드는 Thread와 상관 없이 병행하여 실행한다.
    for (int i = 0; i < 1000; i++)
      System.out.println(">>> " + i);
  }
}

public class Exam0230 {
  public static void main(String[] args) {
    new Thread(() -> {
      for (int i = 0; i < 1000; i++)
        System.out.println("===>" + i);
    }).start();
    
    for (int i = 0; i < 1000; i++)
      System.out.println(">>> " + i);
  }
}

public class Exam0310 {
  
  static class MyThread extends Thread {
    @Override
    public void run() {
      Scanner keyboard = new Scanner(System.in);
      System.out.println("입력하시오> ");
      String input = keyboard.nextLine();
      System.out.println("입력한 문자열 => " + input);
      keyboard.close();
    }
  }
 
  public static void main(String[] args) {
    // main 스레드에서 새 스레드 객체 생성하기
    MyThread t = new MyThread();
    t.start();
    
    // 모든 스레드가 종료될 때까지 JVM은 종료되지 않는다.
    System.out.println("프로그램 종료?");
  }
}