Java服务端如何接收命令行quit命令断开客户端并关闭服务

你当前的服务端主线程会一直阻塞在ServerSocket.accept()方法等待新客户端连接，没有空余逻辑执行命令行输入读取操作，所以无法直接在原有循环里处理控制台指令。

通过三个核心改造实现命令接收与quit逻辑：

• 单独启动守护线程监听控制台输入，不阻塞客户端接入流程
• 用线程安全的集合维护所有活跃客户端连接，方便批量断开
• 加volatile修饰的服务运行状态标记，保证多线程下状态可见，触发quit时有序关闭所有资源

代码改造 #

1. 修改Server主类 #

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.CopyOnWriteArrayList;

public class Server {
    // 存储所有活跃客户端连接，采用线程安全实现
    private static final List<Socket> activeClients = new CopyOnWriteArrayList<>();
    // 服务运行状态，volatile保证多线程可见性
    private static volatile boolean isRunning = true;
    private static ServerSocket serverListener;

    public static void main (String args []) {
        if (args.length < 1) {
            System.err.println("Usage: java Server <port>");
            return;
        }
        int port = Integer.parseInt(args[0]);

        try {
            serverListener = new ServerSocket(port);
            Files input = new Files();

            // 启动独立线程监听控制台命令，设为守护线程不阻塞JVM退出
            Thread consoleThread = new Thread(() -> {
                Scanner scanner = new Scanner(System.in);
                System.out.println("服务启动完成，输入quit即可停止服务");
                while (isRunning) {
                    String command = scanner.nextLine().trim();
                    if ("quit".equalsIgnoreCase(command)) {
                        shutdownServer();
                    } else {
                        System.out.println("不识别的命令，当前仅支持: quit");
                    }
                }
                scanner.close();
            }, "console-command-listener");
            consoleThread.setDaemon(true);
            consoleThread.start();
            
            // 原有客户端接入逻辑，增加运行状态判断
            while (isRunning) {
                System.out.println("Listening...");
                Socket clientSocket = serverListener.accept();
                System.out.println("客户端已连接: " + clientSocket.getRemoteSocketAddress());
                activeClients.add(clientSocket);
                new Thread(new ClientHandler(clientSocket, input, activeClients)).start();
            }
        } catch (IOException e) {
            // 主动关闭服务时accept会抛出异常，仅在非主动关闭场景打印错误
            if (isRunning) {
                System.err.println("I/O操作异常:");
                e.printStackTrace();
            }
        } finally {
            shutdownServer();
        }
    }

    // 服务关闭逻辑
    private static void shutdownServer() {
        if (!isRunning) {
            return;
        }
        isRunning = false;
        System.out.println("开始关闭服务，正在断开所有客户端连接...");
        
        // 逐个关闭活跃客户端连接
        for (Socket client : activeClients) {
            try {
                if (!client.isClosed()) {
                    client.close();
                }
            } catch (IOException e) {
                // 忽略单个客户端关闭异常，不影响整体流程
            }
        }
        activeClients.clear();

        // 关闭服务监听套接字
        try {
            if (serverListener != null && !serverListener.isClosed()) {
                serverListener.close();
            }
        } catch (IOException e) {
            // 忽略监听套接字关闭异常
        }
        System.out.println("服务已完全关闭");
    }
}

2. 调整ClientHandler类 #

需要新增活跃连接集合的构造参数，在连接处理结束时自动从集合中移除当前连接，避免无效连接残留：

import java.io.IOException;
import java.net.Socket;
import java.util.List;

public class ClientHandler implements Runnable {
    private final Socket clientSocket;
    private final Files input;
    private final List<Socket> activeClients;

    // 新增构造参数传入活跃连接集合
    public ClientHandler(Socket clientSocket, Files input, List<Socket> activeClients) {
        this.clientSocket = clientSocket;
        this.input = input;
        this.activeClients = activeClients;
    }

    @Override
    public void run() {
        try {
            // 此处保留你原有的客户端请求处理逻辑
        } catch (Exception e) {
            // 保留原有的异常处理逻辑
        } finally {
            // 连接终止时从活跃集合移除当前连接，释放资源
            activeClients.remove(clientSocket);
            try {
                if (!clientSocket.isClosed()) {
                    clientSocket.close();
                }
            } catch (IOException e) {
                // 忽略连接关闭异常
            }
        }
    }
}

关键说明 #

• 控制台监听必须放在独立线程：accept()是阻塞方法，没有新连接时主线程会一直卡在此处，根本无法执行读取输入的逻辑，独立线程可以和接入逻辑并行运行
• 不要用普通集合存储客户端连接：多个客户端线程、主线程、控制台线程会同时读写连接集合，CopyOnWriteArrayList是线程安全的实现，不会出现并发修改异常
• 运行状态标记必须加volatile：保证一个线程修改isRunning的值后，其他线程能立刻读到最新状态，避免关闭流程卡住
• 资源关闭要做异常隔离：单个客户端连接关闭失败不能影响其他连接和服务整体的关闭流程

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