java socket编程中backlog的含义

小咪咪 2021-09-15 21:56 248阅读 0赞

[https://blog.csdn.net/aitangyong/article/details/49661907][https_blog.csdn.net_aitangyong_article_details_49661907]

使用java.net.ServerSocket能够方便的创建一个服务端套接字，这个类的构造函数有一个参数backlog。下面这段代码，在本机的8888端口上建立了一个套接字，backlog设置为5。

1.  `// port:8888,backlog:5`
2.  `ServerSocket server = new ServerSocket(8888, 5);`

下面的Client是我们的测试类，会创建30个socket连接。

1.  `import java.net.Socket;`
2.   
3.  `public class Client {`
4.  `private static Socket[] clients = new Socket[30];`
5.  `public static void main(String[] args) throws Exception {`
6.  `for (int i = 1; i <= 30; i++) {`
7.  `clients[i-1] = new Socket("127.0.0.1", 8888);`
8.  `System.out.println("client connection:" + i);`
9.  `}`
10. `}`
11. `}`

如果没有启动服务端套接字，那么直接运行Client会报错误：Connection refused: connect。

1.  `Exception in thread "main" java.net.ConnectException: Connection refused: connect`
2.  `at java.net.DualStackPlainSocketImpl.connect0(Native Method)`
3.  `at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:79)`
4.  `at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:339)`
5.  `at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:200)`
6.  `at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:182)`
7.  `at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:172)`
8.  `at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:392)`
9.  `at java.net.Socket.connect(Socket.java:579)`
10. `at java.net.Socket.connect(Socket.java:528)`
11. `at java.net.Socket.<init>(Socket.java:425)`
12. `at java.net.Socket.<init>(Socket.java:208)`

接下来我们启动Server端套接字，但是不调用accept()方法，也就是说不处理客户端的socket连接。

1.  `import java.net.ServerSocket;`
2.   
3.  `public class Server {`
4.   
5.  `public static void main(String[] args) throws Exception{`
6.   
7.  `// port:8888,backlog:5`
8.  `ServerSocket server = new ServerSocket(8888, 5);`
9.   
10. `while(true)`
11. `{`
12.  
13. `}`
14.  
15. `}`
16. `}`

运行Client测试类，运行结果见下图：

![Center][]

可以看到：测试类Client中，前面5个客户端Socket创建是成功的，后面再创建Scoket就会报错。能够成功创建客户端套接字的个数，刚好就是创建ServerSocket时候指定的backlog。

下面这段代码，ServerSocket正常处理客户端socket的连接请求。

1.  `import java.net.ServerSocket;`
2.  `import java.net.Socket;`
3.   
4.  `public class Server {`
5.   
6.  `public static void main(String[] args) throws Exception{`
7.   
8.  `// port:8888,backlog:5`
9.  `ServerSocket server = new ServerSocket(8888, 5);`
10.  
11. `int acceptCount = 0;`
12.  
13. `while(true)`
14. `{`
15. `Socket client = server.accept();`
16.  
17. `acceptCount++;`
18.  
19. `System.out.println("new connection has connected, num=" + acceptCount);`
20. `}`
21.  
22. `}`
23. `}`

运行测试类Client，服务端和客户端的运行结果如下：没有任何异常产生。

![Center 1][]

![Center 2][]

下面我们再修改下服务端代码，处理每个客户端连接需要花费2s，我们用线程睡眠来模拟。

运行测试类Client，服务端和客户端运行结果如下：

![Center 3][]

![Center 4][]

总结一下：

服务端socket处理客户端socket连接是需要一定时间的。ServerSocket有一个队列，存放还没有来得及处理的客户端Socket，这个队列的容量就是backlog的含义。如果队列已经被客户端socket占满了，如果还有新的连接过来，那么ServerSocket会拒绝新的连接。也就是说backlog提供了容量限制功能，避免太多的客户端socket占用太多服务器资源。

客户端每次创建一个Socket对象，服务端的队列长度就会增加1个。

new Socket("127.0.0.1", 8888);

服务端每次accept()，就会从队列中取出一个元素。

Socket client = server.accept();

[https_blog.csdn.net_aitangyong_article_details_49661907]: https://blog.csdn.net/aitangyong/article/details/49661907
[Center]: /images/20210527/1cb92bf18d44487e9fb3a2b76ba489fc.png
[Center 1]: /images/20210527/a5ffba0f33eb400eb5a5c417536fb031.png
[Center 2]: /images/20210527/c59f845482b741ce9958149e84e1436f.png
[Center 3]: /images/20210527/0d8cb01803c84292881ba1f1ef008581.png
[Center 4]: /images/20210527/6d860b40d8e9449ab27443a7ee89df79.png