Java 多线程服务器 - 每个连接都返回数据。在主线程处理？

Question

我正在编写一个带有集成服务器的客户端，该服务器应该无限期地等待新连接 - 并在线程上处理每个连接。

我想在主线程上的系统范围内可用的消息处理程序中处理接收到的字节数组。然而，目前处理显然是在客户端线程上完成的。

我查看了 ExecutorService 的 Futures、submit()，但是当我在服务器内创建客户端连接时，数据将返回到服务器线程。我怎样才能将它从那里返回到主线程（也许在同步数据包存储中？）来处理它而不阻塞服务器？

我当前的实现如下所示：

    public class Server extends Thread {
    private int port;
    private ExecutorService threadPool;

    public Server(int port) {
        this.port = port;
        // 50 simultaneous connections
        threadPool = Executors.newFixedThreadPool(50);
    }

    public void run() {
        try{
            ServerSocket listener = new ServerSocket(this.port);
            System.out.println("Listening on Port " + this.port);
            Socket connection;

            while(true){
                try {
                    connection = listener.accept();
                    System.out.println("Accepted client " + connection.getInetAddress());
                    connection.setSoTimeout(4000);

                    ClientHandler conn_c= new ClientHandler(connection);
                    threadPool.execute(conn_c);
                } catch (IOException e) {
                    System.out.println("IOException on connection: " + e);
                }
            }
        } catch (IOException e) {
            System.out.println("IOException on socket listen: " + e);
            e.printStackTrace();
            threadPool.shutdown();
        }
    }
}
class ClientHandler implements Runnable {
    private Socket connection;

    ClientHandler(Socket connection) {
        this.connection=connection;
    }

    @Override
    public void run() {
        try {
            // Read data from the InputStream, buffered
            int count;
            byte[] buffer = new byte[8192];

            InputStream is = connection.getInputStream();
            ByteArrayOutputStream out = new ByteArrayOutputStream();

            // While there is data in the stream, read it
            while ((count = is.read(buffer)) > 0) {
                out.write(buffer, 0, count);
            }
            is.close();
            out.close();

            System.out.println("Disconnect client " + connection.getInetAddress());
            connection.close();
            // handle the received data
            MessageHandler.handle(out.toByteArray());
        } catch (IOException e) {
            System.out.println("IOException on socket read: " + e);
            e.printStackTrace();
        }
        return;

    }
}

更新： 稳健的方法似乎是 TomTom 建议的 - 使用较新的 java.nio 代替。由于这个项目的用途有限，更多的是一个实验，我想知道将它与 java.io/java.net 一起使用的最佳方法:)

Answer 1

在我的选择中，您可以使用同步对象与主线程聊天，在将客户端连接添加到池中之后，主线程可以阻塞在accept和同步对象上，在客户端处理它之后，将处理后的连接套接字放入并响应队列，然后唤醒同步对象，这样主线程就可以从队列中获取并处理它，主线程处理后，在接受处阻塞并在同步对象处等待。

基本上，你的架构是一种简单/直接的方式，新的方式是使用java nio，以获得更多的并发服务器并获得更好的性能，而且nio也不是最好的方式......

Answer 2

那我将无法扩展。你这样做有什么理由吗？另外，你浪费了大量的内存——你不需要每个套接字一个线程。使用更好的 Java IO 库。就像作为 Java 的一部分使用了大约 10 年的那样（NGIO？）。它用一个套接字处理 x 个线程，只返回数据。