基于线程的Swing客户端/服务端GUI多窗口切换最优方案问询

我有一套简易的Swing客户端与服务端GUI，包含两个客户端窗口，用户可无限制在两者间切换，想了解该场景的最优实现方案。

之前尝试用SwingWorker实现，但切换约10次后服务端停止处理请求。虽然可以设置线程数，但无法预知用户切换次数，这个方案行不通。

当前采用FixedThreadPool，线程数设为CPU核心数（通过Runtime.getRuntime().availableProcessors()获取）。现在的问题是：来回切换约20次后程序偶尔卡顿；打印线程信息时，仅池编号变化，线程编号始终不变（例如：pool-27-thread-1）。

现有代码 #

服务端代码 #

public class Testserver {

    private ServerSocket serverSocket;
    private Socket client;
    private final int PORT = 5432;
    private ObjectOutputStream objectOutputStream;
    private ObjectInputStream objectInputStream;
     private ThreadPoolExecutor executor;

    public Testserver() {
        System.out.println(Thread.currentThread().getName());
        try {
            serverSocket = new ServerSocket(PORT);
            System.out.println("Waiting for connection");

        } catch (IOException ex) {
            Logger.getLogger(Testserver.class.getName()).log(Level.SEVERE, null, ex);
        }

    }

    private void listenForClients() {
        try {

            while (true) {
                client = serverSocket.accept();
                System.out.println("client connected");
                objectOutputStream = new ObjectOutputStream(client.getOutputStream());
                objectInputStream = new ObjectInputStream(client.getInputStream());
                processClient();
            }
        } catch (IOException ex) {
            Logger.getLogger(Testserver.class.getName()).log(Level.SEVERE, null, ex);
        }

    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            new Testserver().listenForClients();
        });
    }
    

    private void processClient() {
        System.out.println("CORES: " + Runtime.getRuntime().availableProcessors());
        executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        
        executor.execute(() -> {
        System.out.println(Thread.currentThread().getName());

        do {
            try {
                String messageFromClient = (String) objectInputStream.readObject();
                System.out.println("[CLIENT] " + messageFromClient);

            } catch (IOException ex) {
            } catch (ClassNotFoundException ex) {
            }
        } while (true);
        });
        
        executor.shutdown();
        
    }

}

客户端代码（CustomerGUI） #

public class CustomerGUI extends JFrame implements ActionListener{
    
    private Socket server;
    private ObjectOutputStream objectOutputStream;
    private ObjectInputStream objectInputStream;
    private JButton btnAdminGUI;
    private final int PORT = 5432;
    
    public CustomerGUI()  {
        
        btnAdminGUI = new JButton("Go to Admin GUI");
               
        try {
            server = new Socket("localhost", PORT);
            System.out.println("Connected to server");
            
            objectOutputStream = new ObjectOutputStream(server.getOutputStream());
            objectInputStream = new ObjectInputStream(server.getInputStream());
        } catch (IOException ex) {
            JOptionPane.showMessageDialog(null, "Error: " + ex.getMessage());
        }
        
        btnAdminGUI.addActionListener(this);
    }
    
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            new CustomerGUI().setGUI();
        });
    }
    
    public void setGUI() {
        setLayout(new GridLayout(2,1));
        add(btnAdminGUI);
        setSize(300, 400);
        setVisible(true);
    }
    

    @Override
    public void actionPerformed(ActionEvent e) {
       if(e.getSource() == btnAdminGUI) {
           new AdminGUI().setGUI();  
           dispose();
       }
    }
}

AdminGUI代码与CustomerGUI基本一致，仅点击按钮后切换至CustomerGUI。

核心问题分析 #

1. 线程池重复创建：服务端processClient()方法每次都会新建FixedThreadPool，处理完就调用executor.shutdown()，导致大量线程池对象被频繁创建销毁，这是卡顿和池编号递增的根本原因。
2. IO流全局共享：服务端用成员变量存储IO流，新客户端连接会覆盖旧引用，导致之前的处理线程读取的是新连接的流，逻辑完全混乱。
3. 客户端连接未关闭：切换GUI时仅调用dispose()，Socket连接未关闭，服务端积累大量无效连接，持续占用资源。
4. 异常处理缺失：IO和反序列化异常直接被吞掉，无法排查连接中断等问题。

最优实现方案 #

1. 服务端改造 #

• 全局单一线程池：初始化时创建一次线程池，复用线程处理所有客户端连接，避免重复开销。
• 隔离客户端资源：每个客户端的Socket、IO流作为局部变量传入处理线程，不共享成员变量。
• 正确处理连接关闭：捕获连接中断异常，及时关闭Socket和流，释放资源。
• 适配IO密集型场景：网络通信属于IO密集型，线程数可设为CPU核心数的2-4倍，提升并发处理能力。

改造后服务端代码：

public class Testserver {

    private ServerSocket serverSocket;
    private final int PORT = 5432;
    // 全局复用线程池，IO密集型场景设为核心数2倍
    private final ThreadPoolExecutor executor;

    public Testserver() {
        System.out.println(Thread.currentThread().getName());
        int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;
        executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(corePoolSize);
        try {
            serverSocket = new ServerSocket(PORT);
            System.out.println("Waiting for connection");

        } catch (IOException ex) {
            Logger.getLogger(Testserver.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void listenForClients() {
        try {
            while (true) {
                Socket client = serverSocket.accept();
                System.out.println("client connected");
                // 每个客户端资源独立传入处理方法
                processClient(client);
            }
        } catch (IOException ex) {
            Logger.getLogger(Testserver.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            // 程序关闭时优雅关闭线程池
            executor.shutdown();
            try {
                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
            }
        }
    }

    public static void main(String[] args) {
        // 监听逻辑不要放在EDT线程，避免阻塞GUI
        new Thread(() -> new Testserver().listenForClients()).start();
    }

    private void processClient(Socket client) {
        executor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            ObjectOutputStream objectOutputStream = null;
            ObjectInputStream objectInputStream = null;
            try {
                objectOutputStream = new ObjectOutputStream(client.getOutputStream());
                objectInputStream = new ObjectInputStream(client.getInputStream());
                String messageFromClient;
                // 读取到null代表连接正常关闭
                while ((messageFromClient = (String) objectInputStream.readObject()) != null) {
                    System.out.println("[CLIENT] " + messageFromClient);
                }
            } catch (EOFException e) {
                System.out.println("客户端连接正常关闭");
            } catch (IOException | ClassNotFoundException ex) {
                Logger.getLogger(Testserver.class.getName()).log(Level.SEVERE, "客户端连接异常", ex);
            } finally {
                // 强制关闭所有资源，避免泄漏
                try {
                    if (objectInputStream != null) objectInputStream.close();
                    if (objectOutputStream != null) objectOutputStream.close();
                    if (client != null) client.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

2. 客户端改造 #

• 切换时关闭连接：重写dispose()方法，关闭Socket和IO流，避免服务端积累无效连接。
• 严格遵循EDT规范：所有GUI操作都在EDT线程执行，保证界面响应流畅。

改造后CustomerGUI代码：

public class CustomerGUI extends JFrame implements ActionListener{
    
    private Socket server;
    private ObjectOutputStream objectOutputStream;
    private ObjectInputStream objectInputStream;
    private JButton btnAdminGUI;
    private final int PORT = 5432;
    
    public CustomerGUI()  {
        btnAdminGUI = new JButton("Go to Admin GUI");
        btnAdminGUI.addActionListener(this);
        try {
            server = new Socket("localhost", PORT);
            System.out.println("Connected to server");
            
            objectOutputStream = new ObjectOutputStream(server.getOutputStream());
            objectInputStream = new ObjectInputStream(server.getInputStream());
        } catch (IOException ex) {
            JOptionPane.showMessageDialog(null, "Error: " + ex.getMessage());
        }
    }
    
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            new CustomerGUI().setGUI();
        });
    }
    
    public void setGUI() {
        setLayout(new GridLayout(2,1));
        add(btnAdminGUI);
        setSize(300, 400);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setVisible(true);
    }
    
    // 重写dispose，关闭连接后再销毁窗口
    @Override
    public void dispose() {
        try {
            if (objectInputStream != null) objectInputStream.close();
            if (objectOutputStream != null) objectOutputStream.close();
            if (server != null) server.close();
            System.out.println("客户端连接已关闭");
        } catch (IOException e) {
            e.printStackTrace();
        }
        super.dispose();
    }

    @Override
    public void actionPerformed(ActionEvent e) {
       if(e.getSource() == btnAdminGUI) {
           SwingUtilities.invokeLater(() -> new AdminGUI().setGUI());  
           dispose();
       }
    }
}

关键优化点总结 #

• 线程池复用：避免重复创建线程池，减少对象开销和线程上下文切换。
• 资源隔离：每个客户端连接的资源独立，防止互相干扰。
• 资源释放：及时关闭Socket和IO流，避免资源泄漏。
• 线程规范：服务端监听逻辑脱离EDT线程，保证Swing GUI响应流畅。

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