当必须接受许多连接时，我在客户端/服务器类型应用程序中使用 Java 套接字时遇到问题

Question

首先，感谢您的阅读。这是我第一次以用户身份使用 stackoverflow，尽管我一直在阅读它并找到有用的解决方案：D。顺便说一句，抱歉，如果我解释得不够清楚，我知道我的英语不是很好。

我的基于套接字的程序有一个奇怪的行为，并且存在一些性能问题。客户端和服务器通过以多线程方式将序列化对象读/写到对象输入和输出流中来相互通信。让我向您展示代码基础知识。我已将其简化为更具可读性，并且故意省略了完整的异常处理。服务器的工作方式如下：

服务器：

// (...)

public void serve() {
    if (serverSocket == null) {
        try {
            serverSocket = (SSLServerSocket) SSLServerSocketFactory
                                    .getDefault().createServerSocket(port);
            serving = true;
            System.out.println("Waiting for clients...");
            while (serving) {
                SSLSocket clientSocket = (SSLSocket) serverSocket.accept();
                System.out.println("Client accepted.");
                //LjServerThread class is below
                new LjServerThread(clientSocket).start();
            }
        } catch (Exception e) {
            // Exception handling code (...)
        }
    }
}

public void stop() {
    serving = false;
    serverSocket = null;
}

public boolean isServing() {
    return serving;
}

LjServerThread 类，每个客户端创建一个实例：

private SSLSocket clientSocket;
private String IP;
private long startTime;

public LjServerThread(SSLSocket clientSocket) {
        this.clientSocket = clientSocket;
        startTime = System.currentTimeMillis();
        this.IP = clientSocket.getInetAddress().getHostAddress();
}

public synchronized String getClientAddress() {
    return IP;
}

@Override
public void run() {
    ObjectInputStream in = null;
    ObjectOutputStream out = null;
    //This is my protocol handling object, and as you will see below,
    //it works processing the object received and returning another as response.
    LjProtocol protocol = new LjProtocol();
    try {
        try {
            in = new ObjectInputStream(new BufferedInputStream(
                                     clientSocket.getInputStream()));
            out = new ObjectOutputStream(new BufferedOutputStream(
                                    clientSocket.getOutputStream()));
            out.flush();
        } catch (Exception ex) {
            // Exception handling code (...)
        }
        LjPacket output;
        while (true) {
            output = protocol.processMessage((LjPacket) in.readObject());
            // When the object received is the finish mark, 
            // protocol.processMessage()object returns null.
            if (output == null) {
                break;
            }
            out.writeObject(output);
            out.flush();
            out.reset();
        }
        System.out.println("Client " + IP + " finished successfully.");
    } catch (Exception ex) {
        // Exception handling code (...)
    } finally {
        try {
            out.close();
            in.close();
            clientSocket.close();
        } catch (Exception ex) {
            // Exception handling code (...)
        } finally {
            long stopTime = System.currentTimeMillis();
            long runTime = stopTime - startTime;
            System.out.println("Run time: " + runTime);
        }
    }
}

并且客户端是这样的：

    private SSLSocket socket;

    @Override
    public void run() {
        LjProtocol protocol = new LjProtocol();
        try {
            socket = (SSLSocket) SSLSocketFactory.getDefault()
                     .createSocket(InetAddress.getByName("here-goes-hostIP"),
                                                                       4444);
        } catch (Exception ex) {

        }
        ObjectOutputStream out = null;
        ObjectInputStream in = null;
        try {
        out = new ObjectOutputStream(new BufferedOutputStream(
                                         socket.getOutputStream()));
        out.flush();
        in = new ObjectInputStream(new BufferedInputStream(
                                          socket.getInputStream()));
        LjPacket output;
        // As the client is which starts the connection, it sends the first 
        //object.
        out.writeObject(/* First object */);
        out.flush();
        while (true) {
            output = protocol.processMessage((LjPacket) in.readObject());
            out.writeObject(output);
            out.flush();
            out.reset();
        }
        } catch (EOFException ex) {
            // If all goes OK, when server disconnects EOF should happen.
            System.out.println("suceed!");
        } catch (Exception ex) {
            // (...)
        } finally {
            try {
                // FIRST STRANGE BEHAVIOUR:
                // I have to comment the "out.close()" line, else, Exception is
                // thrown ALWAYS.
                out.close();
                in.close();
                socket.close();
            } catch (Exception ex) {
                System.out.println("This shouldn't happen!");
            }
        }
    }
}

好吧，如您所见，在服务器端处理接受的客户端的 LjServerThread 类会测量所需的时间。 .. 通常，需要 75 - 120 毫秒（其中 x 是 IP）：

• 客户端 x 成功完成。
• 运行时间：82
• 客户端 x 成功完成。
• 运行时间：80
• 客户端 x 成功完成。
• 运行时间：112
• 客户端 x 成功完成。
• 运行时间：88
• 客户端 x 成功完成。
• 运行时间：90
• 客户端 x 成功完成。
• 运行时间：84

但突然之间，并且没有可预测的模式（至少对我来说）：

• 客户端 x 成功完成。
• 运行时间：15426

有时达到25秒！ 有时，一小群线程会变慢一点，但这并不让我担心：

• Client x 成功完成。
• 运行时间：239
• 客户端 x 成功完成。
• 运行时间：243

为什么会发生这种情况？这可能是因为我的服务器和客户端在同一台机器上，具有相同的 IP？ （为了进行此测试，我在同一台计算机上执行服务器和客户端，但它们通过互联网使用我的公共 IP 连接）。

这就是我测试这个的方法，我在 main() 中向服务器发出这样的请求：

    for (int i = 0; i < 400; i++) {
        try {
            new LjClientThread().start();
            Thread.sleep(100);
        } catch (Exception ex) {
            // (...)
        }
    }

如果我在没有“Thread.sleep(100)”的情况下循环执行它，我会得到一些连接重置异常（7或8个连接重置为400，或多或少），但我想我明白为什么会发生：当 serverSocket.accept() 接受连接时，需要花费很少的时间才能再次到达 serverSocket.accept() 。在此期间，服务器无法接受连接。会不会是因为这个？如果没有，为什么？ 400 个连接同时到达我的服务器的情况很少见，但这种情况有可能发生。如果没有“Thread.sleep(100)”，计时问题也会更糟。

提前致谢！

---

更新：

多么愚蠢，我在本地主机中测试了它......并且它没有给出任何问题！有或没有“Thread.sleep(100)”，都没关系，它工作得很好！为什么！因此，正如我所看到的，我关于为什么抛出连接重置的理论是不正确的。这让事情变得更加奇怪了！我希望有人能帮助我...再次感谢！ :)

---

更新 (2)：

我发现不同操作系统中的行为明显不同。我通常在 Linux 中进行开发，我解释的行为是关于我的 Ubuntu 10.10 中发生的情况。在 Windows 7 中，当我在连接之间暂停 100 毫秒时，一切都很好，并且所有线程都很快，没有人花费超过 150 毫秒左右的时间（没有连接速度慢的问题！）。这不是 Linux 中发生的情况。但是，当我删除“Thread.sleep(100)”时，所有连接都失败并抛出异常，而不是仅某些连接获得连接重置异常（在 Linux 中，只有其中一些连接，400 个连接中只有 6 个左右）都失败了）。

唷！我刚刚发现不仅操作系统，JVM 环境也有一点影响！没什么大不了的，但值得注意。我之前在 Linux 中使用 OpenJDK，现在使用 Oracle JDK，我发现当我减少连接之间的睡眠时间时，它会更早开始失败（50 毫秒 OpenJDK 工作正常，没有抛出异常，但使用 Oracle 的 JDK 时，它会更早地失败）很多睡眠时间为 50 毫秒，而 100 毫秒则效果很好）。

Answer 1

有两点我觉得你可以进一步考虑研究一下。抱歉这里有点含糊，但这就是我的想法。

1) 在底层，在 TCP 级别，很少有与平台相关的东西控制通过套接字发送/接收数据所需的时间。不一致的延迟可能是由于 tcp_syn_retries 等设置造成的。您可能有兴趣查看这里 http://www.frozentux.net /ipsysctl-tutorial/chunkyhtml/tcpvariables.html#AEN370

2）您计算的执行时间不仅是完成执行所花费的时间，还包括完成最终化之前的时间，这不能保证当对象准备好最终化时立即发生。

Answer 2

服务器套接字有一个队列，用于保存传入的连接尝试。如果该队列已满，客户端将遇到连接重置错误。如果没有 Thread.sleep(100) 语句，所有客户端都会尝试相对同时进行连接，这会导致其中一些客户端遇到连接重置错误。