웹 서버를 위한 동시성 프로그래밍 모델

public class Main {

	public static void main(String[] args) throws IOException {
		log.info("start");
		final var counter = new Counter();
		try (var socket = new ServerSocket(8080)) {

			while (true) {
				final var clientSocket = socket.accept();
				log.info("accept client");
				new Thread(new WorkerRunnable(clientSocket, counter)).start();
			}
		}


	}

	static class Counter {

		private Integer count = 0;


		public synchronized Integer increase() {
			return count++;
		}
	}

	static class WorkerRunnable implements Runnable {

		private final Socket clientSocket;
		private final Counter counter;

		public WorkerRunnable(Socket clientSocket, Counter counter) {
			this.clientSocket = clientSocket;
			this.counter = counter;
		}

		@Override
		public void run() {
			try {
				BufferedReader input = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
				OutputStream output = clientSocket.getOutputStream();
				final var time = LocalDateTime.now();
				String readLine;
				String req = "";
				while ((readLine = input.readLine()) != null) {
					if (req.equals("")) {
						req = readLine;
					}
					if (readLine.equals("")) { // If the end of the http request, stop
						break;
					}
				}

				if (req == null || req.equals("") || req.contains("favicon.ico")) {
					return;
				}
				final var increase = counter.increase();

				output.write(
						("HTTP/1.1 200 OK\n\nWorkerRunnable: " +
								increase + " - " + time + "").getBytes()
				);
				output.flush();
				output.close();
				input.close();
				log.info("Request processed: {}", increase);
			} catch (IOException ex) {
				throw new RuntimeException(ex);
			}

		}
	}
}

interface EventHandler {
    void handle(SelectionKey key) throws IOException;
}

public class ReactorEventLoopExample {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.socket().bind(new InetSocketAddress(8080));
        SelectionKey key = serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        key.attach(new AcceptHandler(selector, serverChannel));

        while (true) {
            int readyChannels = selector.select();
            if (readyChannels == 0) continue;
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
            while (keyIterator.hasNext()) {
                SelectionKey selectionKey = keyIterator.next();
                EventHandler handler = (EventHandler) selectionKey.attachment();
                if (handler != null) {
                    handler.handle(selectionKey);
                }
                keyIterator.remove();
            }
        }
    }
}

class AcceptHandler implements EventHandler {
    private final Selector selector;
    private final ServerSocketChannel serverSocketChannel;
    private int counter = 0;  // 카운터 추가

    public AcceptHandler(Selector selector, ServerSocketChannel serverSocketChannel) {
        this.selector = selector;
        this.serverSocketChannel = serverSocketChannel;
    }

    @Override
    public void handle(SelectionKey key) throws IOException {
        SocketChannel clientChannel = serverSocketChannel.accept();
        if (clientChannel != null) {
            counter++;  // 클라이언트가 연결될 때마다 카운터 증가
            System.out.println("Client accepted. Current connection count: " + counter);
            clientChannel.configureBlocking(false);
            SelectionKey clientKey = clientChannel.register(selector, SelectionKey.OP_READ);
            clientKey.attach(new ReadHandler(clientChannel));
        }
    }
}

class ReadHandler implements EventHandler {
    private final SocketChannel socketChannel;

    public ReadHandler(SocketChannel socketChannel) {
        this.socketChannel = socketChannel;
    }

    @Override
    public void handle(SelectionKey key) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(256);
        int read = socketChannel.read(buffer);

        if (read > 0) {
            String output = new String(buffer.array()).trim();
            System.out.println("Received: " + output);
        } else if (read == -1) {
            socketChannel.close();
        }
    }
}