精华内容
下载资源
问答
  • java socket参数详解:BackLog  Java网络编程精解之ServerSocket用法详解 输入连接指示(对连接的请求)的最大队列长度被设置为 backlog 参数。如果队列满时收到连接指示,则拒绝该连接。  注意:  1. backlog...

    java socket参数详解:BackLog

     Java网络编程精解之ServerSocket用法详解

    输入连接指示(对连接的请求)的最大队列长度被设置为 backlog 参数。如果队列满时收到连接指示,则拒绝该连接。 
    注意: 
    1. backlog参数必须是大于 0 的正值。如果传递的值等于或小于 0,则假定为默认值。 
    2. 经过测试这个队列是按照 FIFO(先进先出)的原则。 
    3. 如果将accept这个函数放在一个循环体中时,backlog参数也不会有什么作用。或者简单的讲运行ServerSocket的这个线程会阻塞时,无论是在accept,还是在read处阻塞,这个backlog参数才生效。 
    建一个ServerSocket实例,绑定到端口10000,backlog设置为2

     

    package socket;
    
    import java.io.*;
    import java.net.*;
    import org.apache.log4j.Logger;
    
    public class Test_backlog {
    	private static Logger logger = Logger.getLogger(Test_backlog.class);
    
    	public static void main(String[] args) throws Exception {
    		BufferedReader in = null;
    		PrintWriter out = null;
    		int backlog = 2;
    
    		ServerSocket serversocket = new ServerSocket(10000, backlog);
    		while (true) {
    			logger.debug("启动服务端......");
    			int i;
    			Socket socket = serversocket.accept();
    			logger.debug("有客户端连上服务端, 客户端信息如下:" + socket.getInetAddress() + " : " + socket.getPort() + ".");
    			in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    			out = new PrintWriter(socket.getOutputStream(), true);
    			do {
    				char[] c = new char[1024];
    				i = in.read(c);
    				logger.debug("服务端收到信息: " + new String(c, 0, i));
    			} while (i == -1);
    			out.close();
    			in.close();
    			socket.close();
    			logger.debug("关闭服务端......");
    		}
    	}
    }

     

     

    服务端日志:

    0    [main] DEBUG socket.Test_backlog - 启动服务端......
    3871 [main] DEBUG socket.Test_backlog - 有客户端连上服务端, 客户端信息如下:/127.0.0.1 : 4176.
    18888 [main] DEBUG socket.Test_backlog - 服务端收到信息: 发送完信息我就断掉。
    18888 [main] DEBUG socket.Test_backlog - 关闭服务端......
    18889 [main] DEBUG socket.Test_backlog - 启动服务端......
    18890 [main] DEBUG socket.Test_backlog - 有客户端连上服务端, 客户端信息如下:/127.0.0.1 : 4177.
    45316 [main] DEBUG socket.Test_backlog - 服务端收到信息: 我是第二个客户端,发完后我也断掉。
    45316 [main] DEBUG socket.Test_backlog - 关闭服务端......
    45316 [main] DEBUG socket.Test_backlog - 启动服务端......
    45317 [main] DEBUG socket.Test_backlog - 有客户端连上服务端, 客户端信息如下:/127.0.0.1 : 4178.
    52501 [main] DEBUG socket.Test_backlog - 服务端收到信息: 最后一个拉。
    52501 [main] DEBUG socket.Test_backlog - 关闭服务端......

     

    使用TCP工具连接这个服务端 
    1. 当第一个客户端连接时,服务端打出如下信息: 
    6629 [main] DEBUG socket.Test_backlog - 有客户端连上服务端, 客户端信息如下:/127.0.0.1 : 4110. 
    2. 当第二个客户端连接时,服务端没有打出任何东东。因为这时客户端如果虽然显示成功了,但是被阻在连接队列中。 
    3. 当第三个客户端连接时,情况与2相同。 
    4. 当第四个客户端连接时,连接不上并报错。因为backlog参数设置成2,队列中只有阻塞两个。 
    总结: 
    管理客户连接请求的任务是由操作系统来完成的。操作系统把这些连接请求存储在一个先进先出的队列中。许多操作系统限定了队列的最大长度,一般为50。当队列中的连接请求达到了队列的最大容量时,服务器进程所在的主机会拒绝新的连接请求。只有当服务器进程通过ServerSocket的accept()方法从队列中取出连接请求,使队列腾出空位时,队列才能继续加入新的连接请求。 
    对于客户进程,如果它发出的连接请求被加入到服务器的队列中,就意味着客户与服务器的连接建立成功,客户进程从Socket构造方法中正常返回。如果客户进程发出的连接请求被服务器拒绝,Socket构造方法就会抛出ConnectionException。

    展开全文
  • 这个都是socket的标准参数,并不是netty自己的。...如果未设置或所设置的值小于1,Java将使用默认值50。 ChannelOption.SO_KEEPALIVE,true 是否启用心跳保活机制。在双方TCP套接字建立连接后(...

    这个都是socket的标准参数,并不是netty自己的。

     

    具体为:

    • ChannelOption.SO_BACKLOG, 1024

           BACKLOG用于构造服务端套接字ServerSocket对象,标识当服务器请求处理线程全满时,用于临时存放已完成三次握手的请求的队列的最大长度。如果未设置或所设置的值小于1,Java将使用默认值50。

     

    • ChannelOption.SO_KEEPALIVE, true

          是否启用心跳保活机制。在双方TCP套接字建立连接后(即都进入ESTABLISHED状态)并且在两个小时左右上层没有任何数据传输的情况下,这套机制才会被激活。

     

    • ChannelOption.TCP_NODELAY, true

     在TCP/IP协议中,无论发送多少数据,总是要在数据前面加上协议头,同时,对方接收到数据,也需要发送ACK表示确认。为了尽可能的利用网络带宽,TCP总是希望尽可能的发送足够大的数据。这里就涉及到一个名为Nagle的算法,该算法的目的就是为了尽可能发送大块数据,避免网络中充斥着许多小数据块。

     TCP_NODELAY就是用于启用或关于Nagle算法。如果要求高实时性,有数据发送时就马上发送,就将该选项设置为true关闭Nagle算法;如果要减少发送次数减少网络交互,就设置为false等累积一定大小后再发送。默认为false。

     

    4.ChannelOption.SO_REUSEADDR, true

    SO_REUSEADDR允许启动一个监听服务器并捆绑其众所周知端口,即使以前建立的将此端口用做他们的本地端口的连接仍存在。这通常是重启监听服务器时出现,若不设置此选项,则bind时将出错。
    SO_REUSEADDR允许在同一端口上启动同一服务器的多个实例,只要每个实例捆绑一个不同的本地IP地址即可。对于TCP,我们根本不可能启动捆绑相同IP地址和相同端口号的多个服务器。
    SO_REUSEADDR允许单个进程捆绑同一端口到多个套接口上,只要每个捆绑指定不同的本地IP地址即可。这一般不用于TCP服务器。
    SO_REUSEADDR允许完全重复的捆绑:当一个IP地址和端口绑定到某个套接口上时,还允许此IP地址和端口捆绑到另一个套接口上。一般来说,这个特性仅在支持多播的系统上才有,而且只对UDP套接口而言(TCP不支持多播)
    
    5.ChannelOption.SO_RCVBUF  AND  ChannelOption.SO_SNDBUF 
    定义接收或者传输的系统缓冲区buf的大小,
    
    6.ChannelOption.ALLOCATOR 
    Netty4使用对象池,重用缓冲区
    bootstrap.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
    bootstrap.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);

    大家好,我是程序哥, 一个来自魔都的程序员,小马哥每个月会付我薪水。公众号推出“面试必备”专栏,跟我一起冲刺职场吧!

    展开全文
  • 使用java.net.ServerSocket能够方便的创建一个服务端套接字,这个类的构造函数有一个参数backlog。下面这段代码,在本机的8888端口上建立了一个套接字,backlog设置为5。[java] view plain copy// port:8888,...

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

    [java]  view plain  copy
    1. // port:8888,backlog:5  
    2. ServerSocket server = new ServerSocket(88885);  
    下面的Client是我们的测试类,会创建30个socket连接。
    [java]  view plain  copy
    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。


    [plain]  view plain  copy
    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连接。
    [java]  view plain  copy
    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(88885);  
    9.           
    10.         while(true)  
    11.         {  
    12.                
    13.         }  
    14.                
    15.     }  
    16. }  
    运行Client测试类,运行结果见下图:

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


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

    [java]  view plain  copy
    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(88885);  
    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,服务端和客户端的运行结果如下:没有任何异常产生。





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

    [java]  view plain  copy
    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(88885);  
    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.             Thread.sleep(2 * 1000);  
    22.         }  
    23.                
    24.     }  
    25. }  

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




    总结一下:

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

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

    [java]  view plain  copy
    1. new Socket("127.0.0.1"8888);  

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

    [java]  view plain  copy
    1. Socket client = server.accept();  

    展开全文
  •  java socket参数详解:BackLog   输入连接指示(对连接的请求)的最大队列长度被设置为 backlog 参数。如果队列满时收到连接指示,则拒绝该连接。 注意:  1. backlog参数必须是大于 0 的正值。如果传递的值...



    原文:http://stephen830.iteye.com/blog/2108959


     java socket参数详解:BackLog

     

    输入连接指示(对连接的请求)的最大队列长度被设置为 backlog 参数。如果队列满时收到连接指示,则拒绝该连接。
    注意: 
    1. backlog参数必须是大于 0 的正值。如果传递的值等于或小于 0,则假定为默认值。 
    2. 经过测试这个队列是按照FIFO(先进先出)的原则。
    3. 如果将accept这个函数放在一个循环体中时,backlog参数也不会有什么作用。或者简单的讲运行ServerSocket的这个线程会阻塞时,无论是在accept,还是在read处阻塞,这个backlog参数才生效。
    建一个ServerSocket实例,绑定到端口10000,backlog设置为2

     

    Java代码    收藏代码
    1. package socket;  
    2.   
    3. import java.io.*;  
    4. import java.net.*;  
    5. import org.apache.log4j.Logger;  
    6.   
    7. public class Test_backlog {  
    8.     private static Logger logger = Logger.getLogger(Test_backlog.class);  
    9.   
    10.     public static void main(String[] args) throws Exception {  
    11.         BufferedReader in = null;  
    12.         PrintWriter out = null;  
    13.         int backlog = 2;  
    14.   
    15.         ServerSocket serversocket = new ServerSocket(10000, backlog);  
    16.         while (true) {  
    17.             logger.debug("启动服务端......");  
    18.             int i;  
    19.             Socket socket = serversocket.accept();  
    20.             logger.debug("有客户端连上服务端, 客户端信息如下:" + socket.getInetAddress() + " : " + socket.getPort() + ".");  
    21.             in = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
    22.             out = new PrintWriter(socket.getOutputStream(), true);  
    23.             do {  
    24.                 char[] c = new char[1024];  
    25.                 i = in.read(c);  
    26.                 logger.debug("服务端收到信息: " + new String(c, 0, i));  
    27.             } while (i == -1);  
    28.             out.close();  
    29.             in.close();  
    30.             socket.close();  
    31.             logger.debug("关闭服务端......");  
    32.         }  
    33.     }  
    34. }  

     

     

    服务端日志:

    Python代码    收藏代码
    1. 0    [main] DEBUG socket.Test_backlog - 启动服务端......  
    2. 3871 [main] DEBUG socket.Test_backlog - 有客户端连上服务端, 客户端信息如下:/127.0.0.1 : 4176.  
    3. 18888 [main] DEBUG socket.Test_backlog - 服务端收到信息: 发送完信息我就断掉。  
    4. 18888 [main] DEBUG socket.Test_backlog - 关闭服务端......  
    5. 18889 [main] DEBUG socket.Test_backlog - 启动服务端......  
    6. 18890 [main] DEBUG socket.Test_backlog - 有客户端连上服务端, 客户端信息如下:/127.0.0.1 : 4177.  
    7. 45316 [main] DEBUG socket.Test_backlog - 服务端收到信息: 我是第二个客户端,发完后我也断掉。  
    8. 45316 [main] DEBUG socket.Test_backlog - 关闭服务端......  
    9. 45316 [main] DEBUG socket.Test_backlog - 启动服务端......  
    10. 45317 [main] DEBUG socket.Test_backlog - 有客户端连上服务端, 客户端信息如下:/127.0.0.1 : 4178.  
    11. 52501 [main] DEBUG socket.Test_backlog - 服务端收到信息: 最后一个拉。  
    12. 52501 [main] DEBUG socket.Test_backlog - 关闭服务端......  

     

    使用TCP工具连接这个服务端
    1. 当第一个客户端连接时,服务端打出如下信息:
    6629 [main] DEBUG socket.Test_backlog - 有客户端连上服务端, 客户端信息如下:/127.0.0.1 : 4110.
    2. 当第二个客户端连接时,服务端没有打出任何东东。因为这时客户端如果虽然显示成功了,但是被阻在连接队列中。
    3. 当第三个客户端连接时,情况与2相同。
    4. 当第四个客户端连接时,连接不上并报错。因为backlog参数设置成2,队列中只有阻塞两个。
    总结:
    管理客户连接请求的任务是由操作系统来完成的。操作系统把这些连接请求存储在一个先进先出的队列中。许多操作系统限定了队列的最大长度,一般为50。当队列中的连接请求达到了队列的最大容量时,服务器进程所在的主机会拒绝新的连接请求。只有当服务器进程通过ServerSocket的accept()方法从队列中取出连接请求,使队列腾出空位时,队列才能继续加入新的连接请求。
    对于客户进程,如果它发出的连接请求被加入到服务器的队列中,就意味着客户与服务器的连接建立成功,客户进程从Socket构造方法中正常返回。如果客户进程发出的连接请求被服务器拒绝,Socket构造方法就会抛出ConnectionException。

     

    展开全文
  • 之前在做项目的时候,刚好用到Spring-Integration的TCP/IP组件,在定义ServerSocket的过程中,有一个参数backlog比较突出,通过网上的查阅,才知道这是原生Java中ServerSocket的参数。通过查API得知,ServerSocket的...
  • backlog

    2019-09-23 22:26:39
    “广商百货”BACKLOG ID Name Imp Est How to demo Notes 1 搜索功能 50 8 进入界面有搜索功能,点击搜索按钮输入需要查询的物品或者商店,会有...
  • 使用Java.NET.ServerSocket能够方便的创建一个服务端套接字,这个类的构造函数有一个参数backlog。下面这段代码,在本机的8888端口上建立了一个套接字,backlog设置为5。[java] view plain copy// port:8888,backlog...
  • 传入连接指示(对连接的请求)的最大队列长度被设置为 backlog 参数。如果队列满时收到连接指示,则拒绝该连接。   对传入连接指示有点不解,就做了个简单的测试:写个了服务器程序,创建一个ServerSocket实例,...
  • ChannelOption.SO_BACKLOG对应的是tcp/ip协议listen函数中的backlog参数,函数listen(int socketfd,int backlog)用来初始化服务端可连接队列,服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个...
  • Java开发ERP进销存存源码错误/改进 在 JSON 编辑器中,使按钮的底部类似于 EDIT,添加一个按钮,即“编辑”本身。 在编辑操作的情况下,添加一个按钮,即“JSON 编辑器”。 在 JSON 编辑器中添加一个操作来导入 JSON...
  • backlog是ServerSocket类中的参数,用来指定ServerSocket中等待客户端连接队列的最大数量,并且每调用一次accept方法,就从等待队列中取一个客户端连接出来,因此队列又空闲出一个位置出来,这里有两点需要注意: ...
  • ChannelOption.SO_BACKLOG,1024BACKLOG用于构造服务端套接字ServerSocket对象,标识当服务器请求处理线程全满时,用于临时存放已完成三次握手的请求的队列的最大长度。如果未设置或所设置的值小于1,Java将使用...
  • https://blog.csdn.net/yelllowcong/article/details/78173255 转载于:https://www.cnblogs.com/tc310/p/11127576.html
  • 产品BACKLOG

    2016-06-02 10:48:00
    产品BACKLOG ID Name Imp Est How to demo Notes 1 注册及登录 50 8 进入登录页面,显示注册买家、商家账户按钮,注册、登陆成功显示成功信息并...
  • 积压订单中的订单总数[Number of Orders in the Backlog][中等]——分析及代码[Java]一、题目二、分析及代码1. 优先队列(堆)(1)思路(2)代码(3)结果三、其他 一、题目 给你一个二维整数数组 orders ,其中每...
  • TCP参数之backlog

    2020-09-19 23:54:19
    运维同学的一个问题直接问的我蒙圈:请问你们dubbo的backlog参数设置的是多少? 我是谁,我在哪,我在干什么? backlog参数含义 backlog参数为socket套接字监听端口时,内核为该套接字分配的一个队列大小,在服务端...
  • Backlog 讨论

    千次阅读 2015-11-25 18:22:22
    5. client 返回 ACK 的包后,server 会进入一个新的叫 accept 的队列,该队列的长度为 min(backlog, somaxconn),默认情况下,somaxconn 的值为 128,表示最多有 129 的 ESTAB 的连接等待 accept(),而 backlog 的值...
  • steam-backlog-tracker-源码

    2021-03-05 04:44:57
    steam-backlog-tracker

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,243
精华内容 6,897
热门标签
关键字:

backlogjava

java 订阅