如何实现客户端连接60秒后停止服务器接受新客户端？

我来帮你搞定这个需求——你当前用setSoTimeout实现的是「60秒无客户端连接就停止服务器」，但你要的是「一旦有客户端连接成功，60秒后不管有没有新连接都停止服务器」，这两者的逻辑差异很大，我给你两种可行的实现方案：

方案一：用定时任务精准控制停止时间（推荐） #

这个方案通过ScheduledExecutorService在首次连接成功后启动一个延迟60秒的任务，任务执行时直接关闭ServerSocket并中断主线程，确保服务器停止。

代码示例 #

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class YourServer {
    private String host;
    private int port;
    private ServerSocket serverSocket;
    // 标记是否已启动停止计时器，用volatile保证多线程可见性
    private volatile boolean hasStartedShutdownTimer = false;
    private final ScheduledExecutorService shutdownExecutor = Executors.newSingleThreadScheduledExecutor();

    public YourServer(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() {
        try {
            final InetAddress address = InetAddress.getByName(host);
            serverSocket = new ServerSocket(port, 50, address);

            while (!Thread.currentThread().isInterrupted()) {
                try {
                    // 阻塞等待客户端连接
                    Socket clientSocket = serverSocket.accept();
                    System.out.println("新客户端已连接");

                    // 启动线程处理客户端请求（避免阻塞accept）
                    handleClientConnection(clientSocket);

                    // 首次连接成功后，启动60秒后的停止任务
                    if (!hasStartedShutdownTimer) {
                        hasStartedShutdownTimer = true;
                        shutdownExecutor.schedule(this::shutdownServer, 60, TimeUnit.SECONDS);
                        System.out.println("已启动60秒后停止服务器的计时器");
                    }

                } catch (SocketException e) {
                    // ServerSocket被关闭时会抛出此异常，直接退出循环
                    System.out.println("服务器Socket已关闭，准备停止");
                    break;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            // 清理资源
            shutdownExecutor.shutdown();
            System.out.println("服务器已停止");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void handleClientConnection(Socket clientSocket) {
        // 这里写你的客户端业务处理逻辑，比如读写数据
        new Thread(() -> {
            try (clientSocket) {
                // 示例：读取客户端输入
                // InputStream in = clientSocket.getInputStream();
                // 处理逻辑...
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }

    private void shutdownServer() {
        try {
            // 关闭ServerSocket，让阻塞的accept()抛出异常
            serverSocket.close();
            // 中断主线程，确保while循环退出
            Thread.currentThread().interrupt();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

方案逻辑说明 #

1. 用volatile变量hasStartedShutdownTimer确保多线程下的可见性，避免重复启动停止任务。
2. 首次客户端连接成功后，调度一个60秒后执行的任务，任务会关闭ServerSocket并中断主线程，触发accept()抛出SocketException，从而退出循环。
3. 客户端连接的处理放在单独线程中，避免阻塞accept()影响后续连接。

方案二：用短超时循环检查时间差 #

如果不想引入额外的线程池，也可以通过设置setSoTimeout为较短时间（比如1秒），每次超时后检查是否已经过了首次连接后的60秒。

代码示例 #

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;

public class YourServer {
    private String host;
    private int port;
    private ServerSocket serverSocket;

    public YourServer(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() {
        try {
            final InetAddress address = InetAddress.getByName(host);
            serverSocket = new ServerSocket(port, 50, address);
            // 设置1秒超时，用于定期检查时间
            serverSocket.setSoTimeout(1000);
            // 记录首次连接时间，初始为-1表示还没有连接
            long firstConnectTimestamp = -1;

            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Socket clientSocket = serverSocket.accept();
                    System.out.println("新客户端已连接");
                    handleClientConnection(clientSocket);

                    // 记录首次连接的时间
                    if (firstConnectTimestamp == -1) {
                        firstConnectTimestamp = System.currentTimeMillis();
                        System.out.println("已记录首次连接时间，60秒后停止服务器");
                    }

                } catch (SocketTimeoutException e) {
                    // 超时后检查是否已过60秒
                    if (firstConnectTimestamp != -1) {
                        long elapsedTime = System.currentTimeMillis() - firstConnectTimestamp;
                        if (elapsedTime >= 60 * 1000) {
                            System.out.println("已到停止时间，准备关闭服务器");
                            break;
                        }
                    }
                    // 未到时间，继续等待连接
                } catch (IOException e) {
                    e.printStackTrace();
                    break;
                }
            }

            // 关闭资源
            serverSocket.close();
            System.out.println("服务器已停止");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void handleClientConnection(Socket clientSocket) {
        // 同样在单独线程处理客户端逻辑
        new Thread(() -> {
            try (clientSocket) {
                // 业务处理...
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

方案逻辑说明 #

1. 设置setSoTimeout(1000)让accept()每秒超时一次，这样我们可以定期检查时间。
2. 首次连接成功后记录时间戳，每次超时后计算当前时间与首次连接时间的差值，超过60秒就退出循环停止服务器。
3. 这种方案不需要额外的线程池，但会每秒触发一次超时，对性能影响极小。

内容的提问来源于stack exchange，提问作者Gordon