Java服务器套接字连接限制？

我用套接字运行了一些测试，遇到了一些奇怪的行为：在第50个客户端套接字连接到服务器套接字之后，服务器套接字将拒绝连接，即使在打开下一个客户端套接字之前关闭了该客户端套接字，甚至在连接之间添加了延迟

下面的程序是我的实验代码，它在当前状态下不会抛出异常，并正常终止。但是，如果

Socket[]clients

的数组大小增加到50以上，则服务器套接字将拒绝在第50次连接后尝试连接的任何客户端套接字

问题：为什么50是服务器套接字拒绝套接字连接的计数？

public static void main(String[] args) {
    try (ServerSocket server = new ServerSocket(2123)) {
        Socket[] clients = new Socket[50];
        for (int i = 0; i < clients.length; i++) {
            clients[i] = new Socket("localhost", 2123);
            System.out.printf("Client %2d: " + clients[i] + "%n", i);
            clients[i].close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

publicstaticvoidmain（字符串[]args）{
try（serversocketserver=newserversocket（2123））{
套接字[]客户端=新套接字[50]；
for（int i=0；i

---

我已经运行了另外50个套接字连接到另一个本地服务器的测试，并且在打开和关闭100个套接字时没有发生任何问题，因此我推断是服务器套接字拒绝连接，而不是打开客户端套接字的限制，但我无法发现服务器套接字限制为50个连接的原因，即使它们没有同时连接。

50是积压工作的默认值

传入连接指示（连接请求）的最大队列长度设置为50。如果连接指示在队列已满时到达，则连接将被拒绝

这一切都在：

传入连接指示（连接请求）的最大队列长度设置为50。如果连接指示在队列已满时到达，则连接将被拒绝

显然，您的

ServerSocket

从不接受任何连接，只是侦听。您必须调用

accept（）

并开始处理连接或增加待办事项队列大小：

---

根据@TomaszNurkiewicz的回答，下面是一个有效的例子：

import java.net.*;
import java.util.concurrent.atomic.AtomicBoolean;

public class SockTest{
public static void main(String[] args) {
    final AtomicBoolean shouldRun = new AtomicBoolean(true);
    try  {
        final ServerSocket server = new ServerSocket(2123);
        Thread serverThread = new Thread(){
           public void run() {
              try {
                 while(shouldRun.get()) {
                 Socket s = server.accept();
                 s.close();
             Thread.sleep(1);
                }
              } catch(Exception ex) {
                ex.printStackTrace();
              }
           }
        };
        serverThread.start();
        Socket[] clients = new Socket[150];
        for (int i = 0; i < clients.length; i++) {
            clients[i] = new Socket("localhost", 2123);
            System.out.printf("Client %2d: " + clients[i] + "%n", i);
            clients[i].close();
        }
        shouldRun.set(false);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
       shouldRun.set(false);
    }

  }
}

import java.net.*；
导入java.util.concurrent.AtomicBoolean；
公共类测试{
公共静态void main（字符串[]args）{
最终AtomicBoolean应运行=新的AtomicBoolean（true）；
试一试{
最终ServerSocket服务器=新的ServerSocket（2123）；
线程服务器线程=新线程（）{
公开募捐{
试一试{
while（shouldRun.get（））{
套接字s=server.accept（）；
s、 close（）；
睡眠（1）；
}
}捕获（例外情况除外）{
例如printStackTrace（）；
}
}
};
serverThread.start（）；
套接字[]客户端=新套接字[150]；
for（int i=0；i

您可以看两件事

服务器未接受连接

服务器无法同时处理太多连接实例。它可能是由积压增加（超过50）引起的。在再次连接到服务器之前，请尝试以毫秒为单位提供一些时间间隔。例如，斜坡连接。我通过在运行测试负载时提供一些时间间隔来解决这个问题

---

当客户端套接字关闭时，队列中的连接不会被删除吗？@EJP是的，但是为什么不呢？对我来说，关闭的套接字仍然排队等待连接，这似乎很奇怪。我想服务器套接字无法知道客户端套接字已关闭。@Vulcan在调用accept（）方法时，连接已从队列中删除。抱歉迟到了3年，谢谢；在看到@TomaszNurkiewicz之前的答案后，我实际上创建了一个类似的示例，但没有你的那么干净（我忘记了AtomicBoolean，并用相同的功能创建了自己的临时类，哈哈）+1积压工作不应该依赖于平台吗？

import java.net.*;
import java.util.concurrent.atomic.AtomicBoolean;

public class SockTest{
public static void main(String[] args) {
    final AtomicBoolean shouldRun = new AtomicBoolean(true);
    try  {
        final ServerSocket server = new ServerSocket(2123);
        Thread serverThread = new Thread(){
           public void run() {
              try {
                 while(shouldRun.get()) {
                 Socket s = server.accept();
                 s.close();
             Thread.sleep(1);
                }
              } catch(Exception ex) {
                ex.printStackTrace();
              }
           }
        };
        serverThread.start();
        Socket[] clients = new Socket[150];
        for (int i = 0; i < clients.length; i++) {
            clients[i] = new Socket("localhost", 2123);
            System.out.printf("Client %2d: " + clients[i] + "%n", i);
            clients[i].close();
        }
        shouldRun.set(false);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
       shouldRun.set(false);
    }

  }
}