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

Question

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

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

我查看了 Futures，ExecutorService 的 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

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

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

Answer 2

那我不会缩放。你这样做有什么理由吗？再加上你浪费了大量的内存——你不需要一个线程每个套接字。使用更好的 Java IO 库。就像作为 Java 的一部分使用了 10 年左右的那个（NGIO？）。它用一个套接字处理 x 个线程，只返回数据。