Java Socket服务器如何跳过无客户端连接时的accept()阻塞？

这个问题太常见了！ServerSocket.accept()本身就是阻塞方法——调用它之后，线程会一直卡在那，直到有客户端连进来，自然没法继续执行循环里的其他代码。给你两个最常用的解决思路，附上手写的代码示例：

把等待客户端连接的accept()操作放到单独的线程里，主线程就能自由处理其他业务，不会被阻塞。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TimeServer {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(4000);
        // 用同步列表保证多线程下的读写安全
        final List<Socket> clients = Collections.synchronizedList(new ArrayList<>());

        // 单独开线程处理客户端连接请求
        new Thread(() -> {
            while (true) {
                try {
                    Socket client = server.accept();
                    clients.add(client);
                    System.out.println("新客户端上线：" + client.getInetAddress());
                    
                    // 每个客户端的读写操作也单独开线程，避免一个客户端的慢操作阻塞其他连接
                    new Thread(() -> handleClientInteraction(client, clients)).start();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 主线程在这里处理你的其他业务，完全不会被连接逻辑阻塞
        while (true) {
            // 示例：定时输出在线客户端数量
            System.out.println("当前在线客户端数：" + clients.size());
            try {
                Thread.sleep(3000); // 模拟耗时业务操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static void handleClientInteraction(Socket client, List<Socket> clients) {
        // 这里写和客户端的交互逻辑，比如读取请求、返回响应
        try (BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
             PrintWriter out = new PrintWriter(client.getOutputStream(), true)) {
            
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                out.println("服务器收到：" + inputLine);
                if ("quit".equalsIgnoreCase(inputLine)) {
                    break;
                }
            }
            
            clients.remove(client); // 客户端断开后从列表移除
            client.close();
            System.out.println("客户端下线：" + client.getInetAddress());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

核心要点：

• 连接线程只负责接收新客户端，不处理具体交互，避免阻塞
• 每个客户端的读写都用独立线程，保证多客户端之间互不影响
• 用Collections.synchronizedList避免多线程操作客户端列表时出现并发问题

如果你的服务器需要处理大量客户端连接，NIO的事件驱动模型更高效，不用开大量线程就能管理所有连接。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class NioTimeServer {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        
        serverChannel.bind(new InetSocketAddress(4000));
        serverChannel.configureBlocking(false); // 设置为非阻塞模式
        // 注册"接受连接"事件到Selector
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        while (true) {
            // 先执行你的其他业务逻辑
            System.out.println("处理服务器后台业务...");

            // 等待1秒超时，不管有没有事件都会返回，不会一直阻塞
            int readyChannels = selector.select(1000);
            if (readyChannels == 0) {
                continue; // 没有就绪事件，继续循环处理业务
            }

            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();

                if (key.isAcceptable()) {
                    // 处理新连接
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel client = server.accept();
                    client.configureBlocking(false);
                    // 注册"读取数据"事件到Selector
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("新客户端连接：" + client.getRemoteAddress());
                } else if (key.isReadable()) {
                    // 处理客户端的读请求
                    SocketChannel client = (SocketChannel) key.channel();
                    try {
                        buffer.clear();
                        int bytesRead = client.read(buffer);
                        if (bytesRead == -1) {
                            // 客户端断开连接
                            client.close();
                            key.cancel();
                            continue;
                        }
                        buffer.flip();
                        String message = new String(buffer.array(), 0, buffer.limit()).trim();
                        System.out.println("收到客户端消息：" + message);
                        // 返回响应
                        client.write(ByteBuffer.wrap(("服务器响应：" + message).getBytes()));
                    } catch (IOException e) {
                        client.close();
                        key.cancel();
                    }
                }

                keyIterator.remove(); // 必须移除已处理的key，否则下次循环会重复处理
            }
        }
    }
}

核心要点：

• ServerSocketChannel设置为非阻塞后，accept()不会卡住线程
• 用Selector.select(timeout)设置超时时间，到点后自动返回，主线程可以继续处理其他业务
• 基于事件驱动，一个线程就能处理所有客户端的连接和读写操作，适合高并发场景

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