Java线程池并发Socket服务器实现问题求助

你的核心问题出在线程池的创建位置错误，以及Handler类的实现方式不够合理，导致不仅没发挥线程池的优势，反而带来了额外开销。

主要问题分析 #

• 线程池重复创建：在while(true)循环内部每次接收连接时都新建ThreadPoolExecutor，完全违背了线程池复用线程的设计初衷。每次创建线程池都会初始化10个线程，处理完连接后线程池被销毁、线程回收，频繁的线程创建销毁会带来巨大性能开销，这就是速度比迭代式服务器还慢的原因。
• Handler继承Thread冗余：MultiServerHandler继承Thread类，但线程池执行的是Runnable接口，继承Thread会带来不必要的开销和耦合，直接实现Runnable更合适。

修正后的代码 #

MultiServer 类 #

//MultiServer Class
import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.net.*;
import java.io.*;

public class MultiServer {

    public static void main(String[] args) throws IOException {
        Scanner scnr = new Scanner(System.in);
        
        System.out.println("What port should the server be using?");
        int portNumber = scnr.nextInt();
        
        while ((portNumber < 1025) ||(portNumber > 4998)) {
            System.out.println("Please enter a Port Number between '1025' and '4998'.");
            portNumber = scnr.nextInt();
        }
        
        // 仅创建一次线程池，放在循环外部复用
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        
        try (ServerSocket serverSock = new ServerSocket(portNumber)){
            System.out.println("Server listening on port " + portNumber);

            while(true) {
                Socket sock = serverSock.accept();
                MultiServerHandler msh = new MultiServerHandler(sock);
                executor.execute(msh);
            }
            
        } catch (IOException ex) {
            System.out.println("Server exception: " + ex.getMessage());
            ex.printStackTrace();
        } finally {
            // 服务器退出时优雅关闭线程池
            executor.shutdown();
        }
    }
}

MultiServerHandler 类 #

//MultiServerHandler Class
import java.io.*;
import java.net.*;

// 实现Runnable接口替代继承Thread，更轻量灵活
public class MultiServerHandler implements Runnable {

    private Socket sock;
    
    public MultiServerHandler(Socket sock) {
        this.sock = sock;
    }
    
    @Override
    public void run() {
        try {
            System.out.println("New client connected");

            InputStream input = sock.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(input));

            OutputStream output = sock.getOutputStream();
            PrintWriter writer = new PrintWriter(output, true);

            String command = reader.readLine();
            // 处理空命令，避免执行无效操作
            if (command != null && !command.isEmpty()) {
                Process process = Runtime.getRuntime().exec(command);
                BufferedReader read = new BufferedReader(new InputStreamReader(process.getInputStream()));
                String result;
                
                while((result = read.readLine()) != null) {
                    writer.println(result);
                }
                // 等待外部进程执行完毕，确保资源正常释放
                process.waitFor();
                read.close();
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 用finally块确保Socket一定被关闭，避免资源泄漏
            try {
                sock.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

额外优化说明 #

• 资源可靠释放：通过finally块确保Socket、流等资源在任何情况下都能被关闭，避免资源泄漏。
• 空命令防护：增加对空命令的判断，防止执行无效命令引发异常。
• 线程池优雅关闭：在服务器异常退出时调用executor.shutdown()，让线程池完成现有任务后再关闭，避免任务中断。

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