在另一个线程中处理传入的套接字

Question

我正在尝试做一些可能很愚蠢的事情，但我认为这是个好主意，所以请耐心等待。我尝试实现它，但遇到了一个尴尬的问题，即线程之间的套接字关闭 - 所以我想对这个案例有一些新的看法。

场景

我想通过套接字将对象从Client 写入Server。可能有多个Client同时与Server通信。

Message 对象通过其处理机制由Server 处理。建议不使用Server 的主线程寻找新的传入连接，而是设置Listener 线程。一旦发现传入的连接，它就会提醒Server，将套接字存储在队列中而不接收数据，因此它可以快速返回侦听。

Server 在自己的时间里拿起等待的套接字，生成一个新线程，读取 Message，然后关闭套接字。

代码

这是我关于如何实施的第一个想法。它有一个根本性的缺陷，我将在下面解释。

忽略公共字段的使用 - 我只是想让你们的代码简短

public class Server {
    public boolean messageWaiting = false;

    public static void main(String[] args) {
        new Server().run();
    }

    public void run() {
        Listener l = new Listener();
        l.listen(this);
        try {
            while (true) {
                System.out.println("I'm happily doing my business!");
                Thread.sleep(1000);
                if (messageWaiting) {
                    acceptMessages(l);
                }
            }
        } catch (InterruptedException die) {}
    }

    private void acceptMessages(Listener l) {
        while (!l.waiting.isEmpty()) {
            try (
                Socket client = l.waiting.poll();
                ObjectInputStream ois = new ObjectInputStream(client.getInputStream())
            ) {
                // Handle messages in new threads! (or a thread pool)
                new Thread() {
                    public void run() {
                        try {
                            System.out.println(ois.readObject());
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                    }
                }.start();
            } catch (Exception ex) {
                // Oh no! The socket has already been closed!
                ex.printStackTrace();
            }
        }
    }
}

public class Listener {
    public ConcurrentLinkedQueue<Socket> waiting = new ConcurrentLinkedQueue<>();

    public void listen(final Server callback) {
        new Thread() {
            public void run() {
                try (ServerSocket rxSock = new ServerSocket(7500)) {
                    while (!isInterrupted()) {
                        try (Socket client = rxSock.accept()) {
                            // Once a new socket arrives, add it to the waiting queue
                            waiting.add(client);
                            // Alert the server
                            callback.messageWaiting = true;
                        } catch (IOException ex) {
                            ex.printStackTrace();
                        }
                    }
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }.start();
    }
}

public class Client {
    public static void main(String[] args) {
        try (
            Socket txSock = new Socket(InetAddress.getLoopbackAddress(), 7500);
            ObjectOutputStream oos = new ObjectOutputStream(txSock.getOutputStream())
        ) {

            oos.writeObject("This is a Message, trust me.");
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

这是怎么回事？

这个：

I'm happily doing my business!
I'm happily doing my business!
java.net.SocketException: Socket is closed
    at java.net.Socket.getInputStream(Unknown Source)
    at Server.acceptMessages(Server.java:30)
    at Server.run(Server.java:20)
    at Server.main(Server.java:9)

这是因为我使用的 Java 7 try 块一旦完成就会关闭套接字。那我为什么不手动做呢？试试自己 - 你最终会得到一个警告，说你只会在 null 对象上调用 close()！

那么，我如何避免在Server 线程启动之前关闭传入套接字的整个问题？或者这是一个坏主意，我应该做点别的？

Answer 1

你在Listener的声明

try (Socket client = rxSock.accept()) { ...

是 client 套接字的 try-with-resources。只要将它添加到队列并退出 try 块，套接字就会自动关闭。