自定义ServerSocketChannel无法跟踪变量，多客户端接入同一项目聊天时在线统计/强制断开功能失效

看起来你踩了一个典型的"实例复用逻辑没落地"的坑——你自定义了ServerSocketChannel，但根本没真正实现"获取已有实例"的核心逻辑，还是在每个界面里创建新的服务器对象，那两个关键列表自然还是各自独立的。我给你拆解下问题和具体的修复方案：

问题核心诊断 #

你之前的思路是对的：同一个项目必须对应唯一的服务器实例，才能保证clientChannels和clientInterfaces是全局共享的。但你的代码里还是在直接new CustomServerSocket()，这和没自定义之前的问题完全一样——每个界面都会生成全新的服务器实例，哪怕端口和项目名相同，两个列表也不会共享。

另外还有两个小问题放大了这个问题：

1. 你是在客户端发送消息时才拉取在线人数，非管理员用户如果不发消息，就永远不会更新在线数；
2. 服务器没有主动推送在线人数变化和强制断开的指令，全靠客户端自己拉取，自然会不同步。

具体修复方案 #

第一步：给CustomServerSocket加上实例缓存，实现真正的复用 #

把CustomServerSocket改成单例+项目维度的缓存，确保同一个项目只会有一个服务器实例。

public class CustomServerSocket extends ServerSocketChannel {
    // 用ConcurrentHashMap做线程安全的实例缓存，key是项目名
    private static final Map<String, CustomServerSocket> PROJECT_SERVER_CACHE = new ConcurrentHashMap<>();
    
    private final List<SocketChannel> clientChannels = new CopyOnWriteArrayList<>();
    private final List<Chat_Interface> clientInterfaces = new CopyOnWriteArrayList<>();
    private final String projectName;

    // 私有构造方法，禁止外部直接new
    private CustomServerSocket(SelectorProvider provider, String projectName) throws IOException {
        super(provider);
        this.projectName = projectName;
        this.socket().bind(new InetSocketAddress(5000));
        this.configureBlocking(false);
        System.out.println("项目["+projectName+"]的聊天服务器已启动，端口：5000");
    }

    // 对外提供获取实例的静态方法，核心复用逻辑在这里
    public static CustomServerSocket getInstance(SelectorProvider provider, String projectName) throws IOException {
        // 缓存里有就直接返回，没有才创建新实例并存入缓存
        return PROJECT_SERVER_CACHE.computeIfAbsent(projectName, key -> {
            try {
                CustomServerSocket server = new CustomServerSocket(provider, key);
                // 启动监听线程
                new Thread(server::startListening).start();
                return server;
            } catch (IOException e) {
                throw new RuntimeException("创建项目服务器失败："+e.getMessage(), e);
            }
        });
    }

    // 把原来的监听逻辑移到这个方法里
    private void startListening() {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        while (true) {
            try {
                // 处理新客户端连接
                SocketChannel clientChannel = this.accept();
                if (clientChannel != null) {
                    clientChannel.configureBlocking(false);
                    clientChannels.add(clientChannel);
                    System.out.printf("客户端[%s]已加入项目[%s]聊天%n", clientChannel.socket().getRemoteSocketAddress(), projectName);
                    // 主动给所有客户端推送在线人数更新
                    broadcastOnlineCount();
                }

                // 处理客户端消息和断开
                Iterator<SocketChannel> iterator = clientChannels.iterator();
                while (iterator.hasNext()) {
                    SocketChannel client = iterator.next();
                    try {
                        buffer.clear();
                        int bytesRead = client.read(buffer);
                        if (bytesRead == -1) {
                            // 客户端主动断开
                            handleClientDisconnect(client, iterator);
                        } else if (bytesRead > 0) {
                            // 处理聊天消息
                            buffer.flip();
                            byte[] data = new byte[buffer.remaining()];
                            buffer.get(data);
                            broadcastMessage(new String(data, StandardCharsets.UTF_8));
                        }
                    } catch (IOException e) {
                        // 客户端异常断开
                        handleClientDisconnect(client, iterator);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 处理客户端断开逻辑
    private void handleClientDisconnect(SocketChannel client, Iterator<SocketChannel> iterator) throws IOException {
        System.out.printf("客户端[%s]已离开项目[%s]聊天%n", client.socket().getRemoteSocketAddress(), projectName);
        iterator.remove();
        client.close();
        // 推送更新在线人数
        broadcastOnlineCount();
    }

    // 广播普通聊天消息
    private void broadcastMessage(String message) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put(message.getBytes(StandardCharsets.UTF_8));
        buffer.flip();
        for (SocketChannel client : clientChannels) {
            buffer.rewind();
            while (buffer.hasRemaining()) {
                client.write(buffer);
            }
        }
    }

    // 广播在线人数（用特殊前缀标记，方便客户端识别）
    private void broadcastOnlineCount() throws IOException {
        broadcastMessage("__ONLINE_COUNT__:" + clientChannels.size());
    }

    // 管理员退出时，关闭所有客户端聊天
    public void shutdownAllChats() {
        // 强制关闭所有客户端界面
        for (Chat_Interface chatUI : clientInterfaces) {
            chatUI.disconnect();
        }
        // 清理资源
        clientChannels.forEach(channel -> {
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        clientChannels.clear();
        clientInterfaces.clear();
        // 从缓存移除实例，下次需要时重新创建
        PROJECT_SERVER_CACHE.remove(projectName);
        try {
            this.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 保留原有的getter方法
    public List<SocketChannel> getClientChannels() {
        return clientChannels;
    }

    public List<Chat_Interface> getClientInterfaces() {
        return clientInterfaces;
    }
}

第二步：修改项目界面，用getInstance获取服务器实例 #

替换原来直接new CustomServerSocket的代码，改成调用静态方法获取实例：

// 原来的new CustomServerSocket替换成下面这行
CustomServerSocket server = CustomServerSocket.getInstance(SelectorProvider.provider(), projectName);
new Chat_Interface(server, true, IP_ADDRESS, projectName, frame, joinChatButton);

第三步：修改聊天界面，处理服务器推送的在线人数 #

在Chat_Interface的客户端消息接收逻辑里，加入对在线人数消息的处理：

// 客户端接收消息的逻辑里添加：
String receivedMsg = new String(data, StandardCharsets.UTF_8);
if (receivedMsg.startsWith("__ONLINE_COUNT__:")) {
    // 更新在线人数UI
    String onlineCount = receivedMsg.split(":")[1];
    statusButton.setText(onlineCount);
} else {
    // 处理普通聊天消息，追加到聊天窗口
    chatArea.append(receivedMsg + "\n");
}

第四步：管理员退出时调用shutdownAllChats #

在管理员的退出事件里，调用服务器的shutdownAllChats方法：

// 管理员退出按钮或窗口关闭事件里添加：
if (ownerOfServer) {
    server.shutdownAllChats();
}

为什么之前的自定义方案没用？ #

因为你只是改了ServerSocketChannel的类，但没有改变"每个界面创建新实例"的核心行为——自定义类只是个壳子，真正的复用逻辑要靠静态缓存+私有构造来实现，确保同一个项目只会拿到同一个服务器实例，这样两个列表才会全局共享。

另外用服务器主动推送的方式，也避免了客户端"拉取时机不对"导致的在线数不同步问题，管理员强制断开的指令也能实时推送到所有客户端。

备注：内容来源于stack exchange，提问作者user29054521