활성 세션과 서버 종료

import java.net.ServerSocket;
import java.net.Socket;

public final class UntrackedSessions {
    static void acceptForever(ServerSocket server) throws Exception {
        while (true) {
            Socket socket = server.accept();
            Thread.ofVirtual().start(() -> {
                try {
                    socket.getInputStream().read();
                } catch (Exception ignored) {
                    // 작업은 끝나지만 서버에는 활성 Socket 목록이 없다.
                }
            });
        }
    }

    public static void main(String[] args) throws Exception {
        try (var server = new ServerSocket(0)) {
            System.out.println("listener=" + server.getLocalPort());
            System.out.println("shutdown이 이미 수락된 연결을 찾을 수 없는 구조입니다");
        }
    }
}

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public final class SessionRegistry {
    interface Session extends AutoCloseable {
        @Override void close();
    }

    private final Set<Session> sessions = new HashSet<>();
    private boolean closing;

    public synchronized boolean register(Session session) {
        if (closing) return false;
        return sessions.add(session);
    }

    public synchronized void remove(Session session) {
        sessions.remove(session);
        notifyAll();
    }

    public List<Session> beginClose() {
        synchronized (this) {
            closing = true;
            List<Session> snapshot = new ArrayList<>(sessions);
            sessions.clear();
            return snapshot;
        }
    }

    public synchronized int size() { return sessions.size(); }

    public static void main(String[] args) {
        var registry = new SessionRegistry();
        Session session = () -> System.out.println("closed");
        System.out.println(registry.register(session));
        registry.beginClose().forEach(Session::close);
        System.out.println(registry.register(() -> { }));
    }
}

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.concurrent.atomic.AtomicBoolean;

public final class ManagedSocketSession implements Runnable, AutoCloseable {
    private final Socket socket;
    private final Runnable onClosed;
    private final AtomicBoolean closed = new AtomicBoolean();

    public ManagedSocketSession(Socket socket, Runnable onClosed) {
        this.socket = socket;
        this.onClosed = onClosed;
    }

    @Override public void run() {
        try (var input = new DataInputStream(socket.getInputStream());
             var output = new DataOutputStream(socket.getOutputStream())) {
            String request = input.readUTF();
            output.writeUTF("ok:" + request);
        } catch (Exception error) {
            if (!closed.get()) System.err.println("session failed: " + error);
        } finally {
            close();
        }
    }

    @Override public void close() {
        if (!closed.compareAndSet(false, true)) return;
        try { socket.close(); }
        catch (Exception error) { System.err.println("close failed: " + error); }
        finally { onClosed.run(); }
    }

    public static void main(String[] args) throws Exception {
        try (var socket = new Socket()) {
            var session = new ManagedSocketSession(socket, () -> System.out.println("removed"));
            session.close();
            session.close();
        }
    }
}