HTTP 서버와 연결 수명

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public final class SequentialHttpAcceptor {
    static void serve(ServerSocket listener) throws Exception {
        while (!listener.isClosed()) {
            try (Socket socket = listener.accept();
                 var reader = new BufferedReader(new InputStreamReader(
                         socket.getInputStream(),
                         StandardCharsets.US_ASCII))) {
                while (true) {
                    String line = reader.readLine();
                    if (line == null || line.isEmpty()) {
                        break;
                    }
                }
                Thread.sleep(5_000);
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("compile-only sequential server counterexample");
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public final class OneShotLoopbackHttpServer {
    static String readHead(Socket socket) throws Exception {
        var reader = new BufferedReader(new InputStreamReader(
                socket.getInputStream(),
                StandardCharsets.US_ASCII));
        StringBuilder head = new StringBuilder();
        while (true) {
            String line = reader.readLine();
            if (line == null || line.isEmpty()) {
                return head.toString();
            }
            head.append(line).append('\n');
        }
    }

    static void respond(Socket socket, String body) throws Exception {
        byte[] bodyBytes = body.getBytes(StandardCharsets.UTF_8);
        String head = "HTTP/1.1 200 OK\r\n"
                + "Content-Type: text/plain; charset=UTF-8\r\n"
                + "Content-Length: " + bodyBytes.length + "\r\n"
                + "Connection: close\r\n"
                + "\r\n";
        socket.getOutputStream().write(
                head.getBytes(StandardCharsets.US_ASCII));
        socket.getOutputStream().write(bodyBytes);
        socket.getOutputStream().flush();
    }

    public static void main(String[] args) throws Exception {
        try (var listener = new ServerSocket(
                0,
                8,
                InetAddress.getLoopbackAddress());
             var tasks = java.util.concurrent.Executors
                     .newVirtualThreadPerTaskExecutor()) {
            var handled = tasks.submit(() -> {
                try (Socket socket = listener.accept()) {
                    String head = readHead(socket);
                    respond(socket, "안녕 HTTP");
                    return head.lines().findFirst().orElseThrow();
                }
            });

            try (var client = new Socket(
                    InetAddress.getLoopbackAddress(),
                    listener.getLocalPort())) {
                client.getOutputStream().write((
                        "GET /hello HTTP/1.1\r\n"
                                + "Host: localhost\r\n"
                                + "Connection: close\r\n"
                                + "\r\n")
                        .getBytes(StandardCharsets.US_ASCII));
                client.getOutputStream().flush();

                byte[] response = client.getInputStream().readAllBytes();
                System.out.println(new String(response, StandardCharsets.UTF_8));
            }
            System.out.println("request=" + handled.get());
        }
    }
}

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public final class BoundedHttpDispatcher implements AutoCloseable {
    enum Admission {
        ACCEPTED,
        OVERLOADED,
        CLOSED
    }

    private final ThreadPoolExecutor executor;

    BoundedHttpDispatcher(int workers, int queueCapacity) {
        executor = new ThreadPoolExecutor(
                workers,
                workers,
                0,
                TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(queueCapacity),
                new ThreadPoolExecutor.AbortPolicy());
    }

    Admission submit(Runnable request) {
        if (executor.isShutdown()) {
            return Admission.CLOSED;
        }
        try {
            executor.execute(request);
            return Admission.ACCEPTED;
        } catch (RejectedExecutionException error) {
            return executor.isShutdown()
                    ? Admission.CLOSED
                    : Admission.OVERLOADED;
        }
    }

    record Snapshot(int active, int queued, long completed) {
    }

    Snapshot snapshot() {
        return new Snapshot(
                executor.getActiveCount(),
                executor.getQueue().size(),
                executor.getCompletedTaskCount());
    }

    @Override
    public void close() throws InterruptedException {
        executor.shutdown();
        if (!executor.awaitTermination(1, TimeUnit.SECONDS)) {
            executor.shutdownNow();
        }
    }

    public static void main(String[] args) throws Exception {
        var gate = new CountDownLatch(1);
        List<Admission> results = new ArrayList<>();

        try (var dispatcher = new BoundedHttpDispatcher(1, 1)) {
            for (int index = 0; index < 4; index += 1) {
                results.add(dispatcher.submit(() -> {
                    try {
                        gate.await();
                    } catch (InterruptedException error) {
                        Thread.currentThread().interrupt();
                    }
                }));
            }
            System.out.println(results);
            System.out.println(dispatcher.snapshot());
            gate.countDown();
        }
    }
}