一篇搞懂TCP、HTTP、Socket、Socket连接池

 前言

创新互联建站是专业的镇安网站建设公司，镇安接单;提供成都网站设计、网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行镇安网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

​ 作为一名开发人员我们经常会听到HTTP协议、TCP/IP协议、UDP协议、Socket、Socket长连接、Socket连接池等字眼，然而它们之间的关系、区别及原理并不是所有人都能理解清楚，这篇文章就从网络协议基础开始到Socket连接池，一步一步解释他们之间的关系。

七层网络模型

​ 首先从网络通信的分层模型讲起：七层模型，亦称OSI(Open System Interconnection)模型。自下往上分为：物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。所有有关通信的都离不开它，下面这张图片介绍了各层所对应的一些协议和硬件

通过上图，我知道IP协议对应于网络层，TCP、UDP协议对应于传输层，而HTTP协议对应于应用层，OSI并没有Socket，那什么是Socket，后面我们将结合代码具体详细介绍。

TCP和UDP连接

​ 关于传输层TCP、UDP协议可能我们平时遇见的会比较多，有人说TCP是安全的，UDP是不安全的，UDP传输比TCP快，那为什么呢，我们先从TCP的连接建立的过程开始分析，然后解释UDP和TCP的区别。

TCP的三次握手和四次分手

​ 我们知道TCP建立连接需要经过三次握手，而断开连接需要经过四次分手，那三次握手和四次分手分别做了什么和如何进行的。

第一次握手：建立连接。客户端发送连接请求报文段，将SYN位置为1，Sequence Number为x；然后，客户端进入SYN_SEND状态，等待服务器的确认；

第二次握手：服务器收到客户端的SYN报文段，需要对这个SYN报文段进行确认，设置Acknowledgment Number为x+1(Sequence Number+1)；同时，自己自己还要发送SYN请求信息，将SYN位置为1，Sequence Number为y；服务器端将上述所有信息放到一个报文段（即SYN+ACK报文段）中，一并发送给客户端，此时服务器进入SYN_RECV状态；

第三次握手：客户端收到服务器的SYN+ACK报文段。然后将Acknowledgment Number设置为y+1，向服务器发送ACK报文段，这个报文段发送完毕以后，客户端和服务器端都进入ESTABLISHED状态，完成TCP三次握手。

完成了三次握手，客户端和服务器端就可以开始传送数据。以上就是TCP三次握手的总体介绍。通信结束客户端和服务端就断开连接，需要经过四次分手确认。

第一次分手：主机1（可以使客户端，也可以是服务器端），设置Sequence Number和Acknowledgment Number，向主机2发送一个FIN报文段；此时，主机1进入FIN_WAIT_1状态；这表示主机1没有数据要发送给主机2了；

第二次分手：主机2收到了主机1发送的FIN报文段，向主机1回一个ACK报文段，Acknowledgment Number为Sequence Number加1；主机1进入FIN_WAIT_2状态；主机2告诉主机1，我“同意”你的关闭请求；

第三次分手：主机2向主机1发送FIN报文段，请求关闭连接，同时主机2进入LAST_ACK状态；

第四次分手：主机1收到主机2发送的FIN报文段，向主机2发送ACK报文段，然后主机1进入TIME_WAIT状态；主机2收到主机1的ACK报文段以后，就关闭连接；此时，主机1等待2MSL后依然没有收到回复，则证明Server端已正常关闭，那好，主机1也可以关闭连接了。

可以看到一次tcp请求的建立及关闭至少进行7次通信，这还不包过数据的通信，而UDP不需3次握手和4次分手。

TCP和UDP的区别

　1、TCP是面向链接的，虽然说网络的不安全不稳定特性决定了多少次握手都不能保证连接的可靠性，但TCP的三次握手在最低限度上(实际上也很大程度上保证了)保证了连接的可靠性;而UDP不是面向连接的，UDP传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收，当然也不用重发，所以说UDP是无连接的、不可靠的一种数据传输协议。　

　2、也正由于1所说的特点，使得UDP的开销更小数据传输速率更高，因为不必进行收发数据的确认，所以UDP的实时性更好。知道了TCP和UDP的区别，就不难理解为何采用TCP传输协议的MSN比采用UDP的QQ传输文件慢了，但并不能说QQ的通信是不安全的，因为程序员可以手动对UDP的数据收发进行验证，比如发送方对每个数据包进行编号然后由接收方进行验证啊什么的，即使是这样，UDP因为在底层协议的封装上没有采用类似TCP的“三次握手”而实现了TCP所无法达到的传输效率。

问题

关于传输层我们会经常听到一些问题

1．TCP服务器最大并发连接数是多少？

关于TCP服务器最大并发连接数有一种误解就是“因为端口号上限为65535,所以TCP服务器理论上的可承载的最大并发连接数也是65535”。首先需要理解一条TCP连接的组成部分：客户端IP、客户端端口、服务端IP、服务端端口。所以对于TCP服务端进程来说，他可以同时连接的客户端数量并不受限于可用端口号，理论上一个服务器的一个端口能建立的连接数是全球的IP数*每台机器的端口数。实际并发连接数受限于linux可打开文件数，这个数是可以配置的，可以非常大，所以实际上受限于系统性能。通过#ulimit -n 查看服务的最大文件句柄数，通过ulimit -n xxx 修改 xxx是你想要能打开的数量。也可以通过修改系统参数： 

 
 
 
 
    
  
  
  
  
  1. #vi /etc/security/limits.conf  
    2. 
  
  
  
  
  2. *　　soft　　nofile　　65536  
    3. 
  
  
  
  
  3. *　　hard　　nofile　　65536 
    4.

2．为什么TIME_WAIT状态还需要等2MSL后才能返回到CLOSED状态？

这是因为虽然双方都同意关闭连接了，而且握手的4个报文也都协调和发送完毕，按理可以直接回到CLOSED状态（就好比从SYN_SEND状态到ESTABLISH状态那样）；但是因为我们必须要假想网络是不可靠的，你无法保证你最后发送的ACK报文会一定被对方收到，因此对方处于LAST_ACK状态下的Socket可能会因为超时未收到ACK报文，而重发FIN报文，所以这个TIME_WAIT状态的作用就是用来重发可能丢失的ACK报文。

3．TIME_WAIT状态还需要等2MSL后才能返回到CLOSED状态会产生什么问题

通信双方建立TCP连接后，主动关闭连接的一方就会进入TIME_WAIT状态，TIME_WAIT状态维持时间是两个MSL时间长度，也就是在1-4分钟，Windows操作系统就是4分钟。进入TIME_WAIT状态的一般情况下是客户端，一个TIME_WAIT状态的连接就占用了一个本地端口。一台机器上端口号数量的上限是65536个，如果在同一台机器上进行压力测试模拟上万的客户请求，并且循环与服务端进行短连接通信，那么这台机器将产生4000个左右的TIME_WAIT Socket，后续的短连接就会产生address already in use : connect的异常，如果使用Nginx作为方向代理也需要考虑TIME_WAIT状态，发现系统存在大量TIME_WAIT状态的连接，通过调整内核参数解决。

 
 
 
 
    
  
  
  
  
  1. vi /etc/sysctl.conf 
    2.

编辑文件，加入以下内容： 

 
 
 
 
    
  
  
  
  
  1. net.ipv4.tcp_syncookies = 1  
    2. 
  
  
  
  
  2. net.ipv4.tcp_tw_reuse = 1  
    3. 
  
  
  
  
  3. net.ipv4.tcp_tw_recycle = 1  
    4. 
  
  
  
  
  4. net.ipv4.tcp_fin_timeout = 30 
    5.

然后执行 /sbin/sysctl -p 让参数生效。

net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；

net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；

net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。

net.ipv4.tcp_fin_timeout 修改系統默认的TIMEOUT时间

HTTP协议

关于TCP/IP和HTTP协议的关系，网络有一段比较容易理解的介绍：“我们在传输数据时，可以只使用(传输层)TCP/IP协议，但是那样的话，如果没有应用层，便无法识别数据内容。如果想要使传输的数据有意义，则必须使用到应用层协议。应用层协议有很多，比如HTTP、FTP、TELNET等，也可以自己定义应用层协议。

HTTP协议即超文本传送协议(Hypertext Transfer Protocol )，是Web联网的基础，也是手机联网常用的协议之一，WEB使用HTTP协议作应用层协议，以封装HTTP文本信息，然后使用TCP/IP做传输层协议将它发到网络上。

由于HTTP在每次请求结束后都会主动释放连接，因此HTTP连接是一种“短连接”，要保持客户端程序的在线状态，需要不断地向服务器发起连接请求。通常 的做法是即时不需要获得任何数据，客户端也保持每隔一段固定的时间向服务器发送一次“保持连接”的请求，服务器在收到该请求后对客户端进行回复，表明知道 客户端“在线”。若服务器长时间无法收到客户端的请求，则认为客户端“下线”，若客户端长时间无法收到服务器的回复，则认为网络已经断开。

下面是一个简单的HTTP Post application/json数据内容的请求： 

 
 
 
 
    
  
  
  
  
  1. POST  HTTP/1.1  
    2. 
  
  
  
  
  2. Host: 127.0.0.1:9017  
    3. 
  
  
  
  
  3. Content-Type: application/json  
    4. 
  
  
  
  
  4. Cache-Control: no-cache  
    5. 
  
  
  
  
  5. {"a":"a"} 
    6.

关于Socket（套接字）

现在我们了解到TCP/IP只是一个协议栈，就像操作系统的运行机制一样，必须要具体实现，同时还要提供对外的操作接口。就像操作系统会提供标准的编程接口，比如Win32编程接口一样，TCP/IP也必须对外提供编程接口，这就是Socket。现在我们知道，Socket跟TCP/IP并没有必然的联系。Socket编程接口在设计的时候，就希望也能适应其他的网络协议。所以，Socket的出现只是可以更方便的使用TCP/IP协议栈而已，其对TCP/IP进行了抽象，形成了几个最基本的函数接口。比如create，listen，accept，connect，read和write等等。

不同语言都有对应的建立Socket服务端和客户端的库，下面举例Nodejs如何创建服务端和客户端：

服务端： 

 
 
 
 
    
  
  
  
  
  1. const net = require('net');  
    2. 
  
  
  
  
  2. const server = net.createServer();  
    3. 
  
  
  
  
  3. server.on('connection', (client) => {  
    4. 
  
  
  
  
  4.   client.write('Hi!\n'); // 服务端向客户端输出信息，使用 write() 方法  
    5. 
  
  
  
  
  5.   client.write('Bye!\n');  
    6. 
  
  
  
  
  6.   //client.end(); // 服务端结束该次会话  
    7. 
  
  
  
  
  7. });  
    8. 
  
  
  
  
  8. server.listen(9000); 
    9.

服务监听9000端口

下面使用命令行发送http请求和telnet 

 
 
 
 
    
  
  
  
  
  1. $ curl http://127.0.0.1:9000  
    2. 
  
  
  
  
  2. Bye!  
    3. 
  
  
  
  
  3. $telnet 127.0.0.1 9000  
    4. 
  
  
  
  
  4. Trying 192.168.1.21...  
    5. 
  
  
  
  
  5. Connected to 192.168.1.21.  
    6. 
  
  
  
  
  6. Escape character is '^]'.  
    7. 
  
  
  
  
  7. Hi!  
    8. 
  
  
  
  
  8. Bye!  
    9. 
  
  
  
  
  9. Connection closed by foreign host. 
    10.

注意到curl只处理了一次报文。

客户端 

 
 
 
 
    
  
  
  
  
  1. const client = new net.Socket();  
    2. 
  
  
  
  
  2. client.connect(9000, '127.0.0.1', function () {  
    3. 
  
  
  
  
  3. });  
    4. 
  
  
  
  
  4. client.on('data', (chunk) => {  
    5. 
  
  
  
  
  5.   console.log('data', chunk.toString())  
    6. 
  
  
  
  
  6.   //data Hi!  
    7. 
  
  
  
  
  7.   //Bye!  
    8. 
  
  
  
  
  8. }); 
    9.

Socket长连接

所谓长连接，指在一个TCP连接上可以连续发送多个数据包，在TCP连接保持期间，如果没有数据包发送，需要双方发检测包以维持此连接(心跳包)，一般需要自己做在线维持。 短连接是指通信双方有数据交互时，就建立一个TCP连接，数据发送完成后，则断开此TCP连接。比如Http的，只是连接、请求、关闭，过程时间较短,服务器若是一段时间内没有收到请求即可关闭连接。其实长连接是相对于通常的短连接而说的，也就是长时间保持客户端与服务端的连接状态。

通常的短连接操作步骤是：

连接→数据传输→关闭连接；

而长连接通常就是：

连接→数据传输→保持连接(心跳)→数据传输→保持连接(心跳)→……→关闭连接；

什么时候用长连接，短连接？

长连接多用于操作频繁，点对点的通讯，而且连接数不能太多情况，。每个TCP连接都需要三步握手，这需要时间，如果每个操作都是先连接，再操作的话那么处理 速度会降低很多，所以每个操作完后都不断开，次处理时直接发送数据包就OK了，不用建立TCP连接。例如：数据库的连接用长连接， 如果用短连接频繁的通信会造成Socket错误，而且频繁的Socket创建也是对资源的浪费。

什么是心跳包为什么需要：

心跳包就是在客户端和服务端间定时通知对方自己状态的一个自己定义的命令字，按照一定的时间间隔发送，类似于心跳，所以叫做心跳包。网络中的接收和发送数据都是使用Socket进行实现。但是如果此套接字已经断开（比如一方断网了），那发送数据和接收数据的时候就一定会有问题。可是如何判断这个套接字是否还可以使用呢？这个就需要在系统中创建心跳机制。其实TCP中已经为我们实现了一个叫做心跳的机制。如果你设置了心跳，那TCP就会在一定的时间（比如你设置的是3秒钟）内发送你设置的次数的心跳（比如说2次），并且此信息不会影响你自己定义的协议。也可以自己定义，所谓“心跳”就是定时发送一个自定义的结构体（心跳包或心跳帧），让对方知道自己“在线”,以确保链接的有效性。

实现：

服务端： 

 
 
 
 
    
  
  
  
  
  1. const net = require('net');  
    2. 
  
  
  
  
  2. let clientList = [];  
    3. 
  
  
  
  
  3. const heartbeat = 'HEARTBEAT'; // 定义心跳包内容确保和平时发送的数据不会冲突  
    4. 
  
  
  
  
  4. const server = net.createServer();  
    5. 
  
  
  
  
  5. server.on('connection', (client) => {  
    6. 
  
  
  
  
  6.   console.log('客户端建立连接:', client.remoteAddress + ':' + client.remotePort);  
    7. 
  
  
  
  
  7.   clientList.push(client);  
    8. 
  
  
  
  
  8.   client.on('data', (chunk) => {  
    9. 
  
  
  
  
  9.     let content = chunk.toString();  
    10. 
  
  
  
  
  10.     if (content === heartbeat) {  
    11. 
  
  
  
  
  11.       console.log('收到客户端发过来的一个心跳包');  
    12. 
  
  
  
  
  12.     } else {  
    13. 
  
  
  
  
  13.       console.log('收到客户端发过来的数据:', content);  
    14. 
  
  
  
  
  14.       client.write('服务端的数据:' + content);  
    15. 
  
  
  
  
  15.     }  
    16. 
  
  
  
  
  16.   });  
    17. 
  
  
  
  
  17.   client.on('end', () => {  
    18. 
  
  
  
  
  18.     console.log('收到客户端end');  
    19. 
  
  
  
  
  19.     clientList.splice(clientList.indexOf(client), 1);  
    20. 
  
  
  
  
  20.   });  
    21. 
  
  
  
  
  21.   client.on('error', () => {  
    22. 
  
  
  
  
  22.     clientList.splice(clientList.indexOf(client), 1);  
    23. 
  
  
  
  
  23.   })  
    24. 
  
  
  
  
  24. });  
    25. 
  
  
  
  
  25. server.listen(9000);  
    26. 
  
  
  
  
  26. setInterval(broadcast, 10000); // 定时发送心跳包  
    27. 
  
  
  
  
  27. function broadcast() {  
    28. 
  
  
  
  
  28.   console.log('broadcast heartbeat', clientList.length);  
    29. 
  
  
  
  
  29.   let cleanup = []  
    30. 
  
  
  
  
  30.   for (let i=0;i
  
  
  
  
  31.     if (clientList[i].writable) { // 先检查 sockets 是否可写  
    32. 
  
  
  
  
  32.       clientList[i].write(heartbeat);  
    33. 
  
  
  
  
  33.     } else {  
    34. 
  
  
  
  
  34.       console.log('一个无效的客户端');  
    35. 
  
  
  
  
  35.       cleanup.push(clientList[i]); // 如果不可写，收集起来销毁。销毁之前要 Socket.destroy() 用 API 的方法销毁。 
    36. 
  
  
  
  
  36.       clientList[i].destroy();  
    37. 
  
  
  
  
  37.     }  
    38. 
  
  
  
  
  38.   }  
    39. 
  
  
  
  
  39.   //Remove dead Nodes out of write loop to avoid trashing loop index  
    40. 
  
  
  
  
  40.   for (let i=0; i
  
  
  
  
  41.     console.log('删除无效的客户端:', cleanup[i].name);  
    42. 
  
  
  
  
  42.     clientList.splice(clientList.indexOf(cleanup[i]), 1);  
    43. 
  
  
  
  
  43.   }  
    44. 
  
  
  
  
  44. } 
    45.

服务端输出结果： 

 
 
 
 
    
  
  
  
  
  1. 客户端建立连接: ::ffff:127.0.0.1:57125  
    2. 
  
  
  
  
  2. broadcast heartbeat 1  
    3. 
  
  
  
  
  3. 收到客户端发过来的数据: Thu, 29 Mar 2018 03:45:15 GMT  
    4. 
  
  
  
  
  4. 收到客户端发过来的一个心跳包  
    5. 
  
  
  
  
  5. 收到客户端发过来的数据: Thu, 29 Mar 2018 03:45:20 GMT  
    6. 
  
  
  
  
  6. broadcast heartbeat 1  
    7. 
  
  
  
  
  7. 收到客户端发过来的数据: Thu, 29 Mar 2018 03:45:25 GMT  
    8. 
  
  
  
  
  8. 收到客户端发过来的一个心跳包  
    9. 
  
  
  
  
  9. 客户端建立连接: ::ffff:127.0.0.1:57129  
    10. 
  
  
  
  
  10. 收到客户端发过来的一个心跳包  
    11. 
  
  
  
  
  11. 收到客户端发过来的数据: Thu, 29 Mar 2018 03:46:00 GMT  
    12. 
  
  
  
  
  12. 收到客户端发过来的数据: Thu, 29 Mar 2018 03:46:04 GMT  
    13. 
  
  
  
  
  13. broadcast heartbeat 2  
    14. 
  
  
  
  
  14. 收到客户端发过来的数据: Thu, 29 Mar 2018 03:46:05 GMT  
    15. 
  
  
  
  
  15. 收到客户端发过来的一个心跳包 
    16.

客户端代码： 

 
 
 
 
    
  
  
  
  
  1. const net = require('net');  
    2. 
  
  
  
  
  2. const heartbeat = 'HEARTBEAT';   
    3. 
  
  
  
  
  3. const client = new net.Socket();  
    4. 
  
  
  
  
  4. client.connect(9000, '127.0.0.1', () => {});  
    5. 
  
  
  
  
  5. client.on('data', (chunk) => {  
    6. 
  
  
  
  
  6.   let content = chunk.toString();  
    7. 
  
  
  
  
  7.   if (content === heartbeat) {  
    8. 
  
  
  
  
  8.     console.log('收到心跳包：', content);  
    9. 
  
  
  
  
  9.   } else {  
    10. 
  
  
  
  
  10.     console.log('收到数据：', content);  
    11. 
  
  
  
  
  11.   }  
    12. 
  
  
  
  
  12. });  
    13. 
  
  
  
  
  13. // 定时发送数据  
    14. 
  
  
  
  
  14. setInterval(() => {  
    15. 
  
  
  
  
  15.   console.log('发送数据', new Date().toUTCString());  
    16. 
  
  
  
  
  16.   client.write(new Date().toUTCString());  
    17. 
  
  
  
  
  17. }, 5000);  
    18. 
  
  
  
  
  18. // 定时发送心跳包  
    19. 
  
  
  
  
  19. setInterval(function () {  
    20. 
  
  
  
  
  20.   client.write(heartbeat);  
    21. 
  
  
  
  
  21. }, 10000); 
    22.

客户端输出结果： 

 
 
 
 
    
  
  
  
  
  1. 发送数据 Thu, 29 Mar 2018 03:46:04 GMT  
    2. 
  
  
  
  
  2. 收到数据： 服务端的数据:Thu, 29 Mar 2018 03:46:04 GMT  
    3. 
  
  
  
  
  3. 收到心跳包： HEARTBEAT  
    4. 
  
  
  
  
  4. 发送数据 Thu, 29 Mar 2018 03:46:09 GMT  
    5. 
  
  
  
  
  5. 收到数据： 服务端的数据:Thu, 29 Mar 2018 03:46:09 GMT  
    6. 
  
  
  
  
  6. 发送数据 Thu, 29 Mar 2018 03:46:14 GMT  
    7. 
  
  
  
  
  7. 收到数据： 服务端的数据:Thu, 29 Mar 2018 03:46:14 GMT  
    8. 
  
  
  
  
  8. 收到心跳包： HEARTBEAT  
    9. 
  
  
  
  
  9. 发送数据 Thu, 29 Mar 2018 03:46:19 GMT  
    10. 
  
  
  
  
  10. 收到数据： 服务端的数据:Thu, 29 Mar 2018 03:46:19 GMT  
    11. 
  
  
  
  
  11. 发送数据 Thu, 29 Mar 2018 03:46:24 GMT  
    12. 
  
  
  
  
  12. 收到数据： 服务端的数据:Thu, 29 Mar 2018 03:46:24 GMT  
    13. 
  
  
  
  
  13. 收到心跳包： HEARTBEAT 
    14.

定义自己的协议

如果想要使传输的数据有意义，则必须使用到应用层协议比如Http、Mqtt、Dubbo等。基于TCP协议上自定义自己的应用层的协议需要解决的几个问题：

  1.  心跳包格式的定义及处理
  2.  报文头的定义，就是你发送数据的时候需要先发送报文头，报文里面能解析出你将要发送的数据长度
  3.  你发送数据包的格式，是json的还是其他序列化的方式

下面我们就一起来定义自己的协议，并编写服务的和客户端进行调用：

定义报文头格式： length:000000000xxxx; xxxx代表数据的长度，总长度20,举例子不严谨。

数据表的格式: Json

服务端: 

 
 
 
 
    
  
  
  
  
  1. const net = require('net');  
    2. 
  
  
  
  
  2. const server = net.createServer();  
    3. 
  
  
  
  
  3. let clientList = [];  
    4. 
  
  
  
  
  4. const heartBeat = 'HeartBeat'; // 定义心跳包内容确保和平时发送的数据不会冲突  
    5. 
  
  
  
  
  5. const getHeader = (num) => {  
    6. 
  
  
  
  
  6.   return 'length:' + (Array(13).join(0) + num).slice(-13); 
    7. 
  
  
  
  
  7. }  
    8. 
  
  
  
  
  8. server.on('connection', (client) => {  
    9. 
  
  
  
  
  9.   clientclient.name = client.remoteAddress + ':' + client.remotePort  
    10. 
  
  
  
  
  10.   // client.write('Hi ' + client.name + '!\n');  
    11. 
  
  
  
  
  11.   console.log('客户端建立连接', client.name);  
    12. 
  
  
  
  
  12.   clientList.push(client)  
    13. 
  
  
  
  
  13.   let chunks = []; 
    14. 
  
  
  
  
  14.   let length = 0;  
    15. 
  
  
  
  
  15.   client.on('data', (chunk) => {  
    16. 
  
  
  
  
  16.     let content = chunk.toString();  
    17. 
  
  
  
  
  17.     console.log("content:", content, content.length);  
    18. 
  
  
  
  
  18.     if (content === heartBeat) { 
    19. 
  
  
  
  
  19.        console.log('收到客户端发过来的一个心跳包');  
    20. 
  
  
  
  
  20.     } else {  
    21. 
  
  
  
  
  21.       if (content.indexOf('length:') === 0){  
    22. 
  
  
  
  
  22.         length = parseInt(content.substring(7,20));  
    23. 
  
  
  
  
  23.         console.log('length', length);  
    24. 
  
  
  
  
  24.         chunks =[chunk.slice(20, chunk.length)];  
    25. 
  
  
  
  
  25.       } else {  
    26. 
  
  
  
  
  26.         chunks.push(chunk);  
    27. 
  
  
  
  
  27.       }  
    28. 
  
  
  
  
  28.       let heap = Buffer.concat(chunks);  
    29. 
  
  
  
  
  29.       console.log('heap.length', heap.length)  
    30. 
  
  
  
  
  30.       if (heap.length >= length) {  
    31. 
  
  
  
  
  31.         try {  
    32. 
  
  
  
  
  32.           console.log('收到数据', JSON.parse(heap.toString()));  
    33. 
  
  
  
  
  33.           let data = '服务端的数据数据:' + heap.toString();;  
    34. 
  
  
  
  
  34.           let dataBuff =  Buffer.from(JSON.stringify(data));  
    35. 
  
  
  
  
  35.           let header = getHeader(dataBuff.length)  
    36. 
  
  
  
  
  36.           client.write(header);  
    37. 
  
  
  
  
  37.           client.write(dataBuff);  
    38. 
  
  
  
  
  38.         } catch (err) {  
    39. 
  
  
  
  
  39.           console.log('数据解析失败');  
    40. 
  
  
  
  
  40.         }  
    41. 
  
  
  
  
  41.       }  
    42. 
  
  
  
  
  42.     }  
    43. 
  
  
  
  
  43.   })  
    44. 
  
  
  
  
  44.   client.on('end', () => {  
    45. 
  
  
  
  
  45.     console.log('收到客户端end');  
    46. 
  
  
  
  
  46.     clientList.splice(clientList.indexOf(client), 1);  
    47. 
  
  
  
  
  47.   });  
    48. 
  
  
  
  
  48.   client.on('error', () => {  
    49. 
  
  
  
  
  49.     clientList.splice(clientList.indexOf(client), 1);  
    50. 
  
  
  
  
  50.   })  
    51. 
  
  
  
  
  51. });  
    52. 
  
  
  
  
  52. server.listen(9000);  
    53. 
  
  
  
  
  53. setInterval(broadcast, 10000); // 定时检查客户端 并发送心跳包  
    54. 
  
  
  
  
  54. function broadcast() {  
    55. 
  
  
  
  
  55.   console.log('broadcast heartbeat', clientList.length);  
    56. 
  
  
  
  
  56.   let cleanup = []  
    57. 
  
  
  
  
  57.   for(var i=0;i
  
  
  
  
  58.     if(clientList[i].writable) { // 先检查 sockets 是否可写  
    59. 
  
  
  
  
  59.       // clientList[i].write(heartBeat); // 发送心跳数据  
    60. 
  
  
  
  
  60.     } else {  
    61. 
  
  
  
  
  61.       console.log('一个无效的客户端')  
    62. 
  
  
  
  
  62.       cleanup.push(clientList[i]) // 如果不可写，收集起来销毁。销毁之前要 Socket.destroy() 用 API 的方法销毁。  
    63. 
  
  
  
  
  63.       clientList[i].destroy();  
    64. 
  
  
  
  
  64.     }  
    65. 
  
  
  
  
  65.   } 
    66. 
  
  
  
  
  66.   // 删除无效的客户端  
    67. 
  
  
  
  
  67.   for(i=0; i
  
  
  
  
  68.     console.log('删除无效的客户端:', cleanup[i].name);  
    69. 
  
  
  
  
  69.     clientList.splice(clientList.indexOf(cleanup[i]), 1)  
    70. 
  
  
  
  
  70.   }  
    71. 
  
  
  
  
  71. } 
    72.

日志打印： 

 
 
 
 
    
  
  
  
  
  1. 客户端建立连接 ::ffff:127.0.0.1:50178 
    2. 
  
  
  
  
  2.  content: length:0000000000031 20  
    3. 
  
  
  
  
  3. length 31  
    4. 
  
  
  
  
  4. heap.length 0  
    5. 
  
  
  
  
  5. content: "Tue, 03 Apr 2018 06:12:37 GMT" 31  
    6. 
  
  
  
  
  6. heap.length 31  
    7. 
  
  
  
  
  7. 收到数据 Tue, 03 Apr 2018 06:12:37 GMT  
    8. 
  
  
  
  
  8. broadcast heartbeat 1  
    9. 
  
  
  
  
  9. content: HeartBeat 9  
    10. 
  
  
  
  
  10. 收到客户端发过来的一个心跳包  
    11. 
  
  
  
  
  11. content: length:0000000000031"Tue, 03 Apr 2018 06:12:42 GMT" 51  
    12. 
  
  
  
  
  12. length 31  
    13. 
  
  
  
  
  13. heap.length 31  
    14. 
  
  
  
  
  14. 收到数据 Tue, 03 Apr 2018 06:12:42 GMT 
    15.

客户端 

 
 
 
 
    
  
  
  
  
  1. const net = require('net');  
    2. 
  
  
  
  
  2. const client = new net.Socket();  
    3. 
  
  
  
  
  3. const heartBeat = 'HeartBeat'; // 定义心跳包内容确保和平时发送的数据不会冲突  
    4. 
  
  
  
  
  4. const getHeader = (num) => {  
    5. 
  
  
  
  
  5.   return 'length:' + (Array(13).join(0) + num).slice(-13);  
    6. 
  
  
  
  
  6. }  
    7. 
  
  
  
  
  7. client.connect(9000, '127.0.0.1', function () {});  
    8. 
  
  
  
  
  8. let chunks = [];  
    9. 
  
  
  
  
  9. let length = 0;  
    10. 
  
  
  
  
  10. client.on('data', (chunk) => {  
    11. 
  
  
  
  
  11.   let content = chunk.toString(); 
    12. 
  
  
  
  
  12.    console.log("content:", content, content.length);  
    13. 
  
  
  
  
  13.   if (content === heartBeat) {  
    14. 
  
  
  
  
  14.     console.log('收到服务端发过来的一个心跳包');  
    15. 
  
  
  
  
  15.   } else {  
    16. 
  
  
  
  
  16.     if (content.indexOf('length:') === 0){  
    17. 
  
  
  
  
  17.       length = parseInt(content.substring(7,20));  
    18. 
  
  
  
  
  18.       console.log('length', length);  
    19. 
  
  
  
  
  19.       chunks =[chunk.slice(20, chunk.length)];  
    20. 
  
  
  
  
  20.     } else {  
    21. 
  
  
  
  
  21.       chunks.push(chunk);  
    22. 
  
  
  
  
  22.     }  
    23. 
  
  
  
  
  23.     let heap = Buffer.concat(chunks);  
    24. 
  
  
  
  
  24.     console.log('heap.length', heap.length)  
    25. 
  
  
  
  
  25.     if (heap.length >= length) {  
    26. 
  
  
  
  
  26.       try {  
    27. 
  
  
  
  
  27.         console.log('收到数据', JSON.parse(heap.toString()));  
    28. 
  
  
  
  
  28.       } catch (err) {  
    29. 
  
  
  
  
  29.         console.log('数据解析失败');  
    30. 
  
  
  
  
  30.       }  
    31. 
  
  
  
  
  31.     }  
    32. 
  
  
  
  
  32.   }  
    33. 
  
  
  
  
  33. });  
    34. 
  
  
  
  
  34. // 定时发送数据  
    35. 
  
  
  
  
  35. setInterval(function () {  
    36. 
  
  
  
  
  36.   let data = new Date().toUTCString();  
    37. 
  
  
  
  
  37.   let dataBuff =  Buffer.from(JSON.stringify(data));  
    38. 
  
  
  
  
  38.   let header =getHeader(dataBuff.length);  
    39. 
  
  
  
  
  39.   client.write(header); 
    40. 
  
  
  
  
  40.    client.write(dataBuff);  
    41. 
  
  
  
  
  41. }, 5000);  
    42. 
  
  
  
  
  42. // 定时发送心跳包  
    43. 
  
  
  
  
  43. setInterval(function () {  
    44. 
  
  
  
  
  44.   client.write(heartBeat);  
    45. 
  
  
  
  
  45. }, 10000); 
    46.

日志打印： 

 
 
 
 
    
  
  
  
  
  1. content: length:0000000000060 20  
    2. 
  
  
  
  
  2. length 60  
    3. 
  
  
  
  
  3. heap.length 0  
    4. 
  
  
  
  
  4. content: "服务端的数据数据:\"Tue, 03 Apr 2018 06:12:37 GMT\"" 44  
    5. 
  
  
  
  
  5. heap.length 60  
    6. 
  
  
  
  
  6. 收到数据 服务端的数据数据:"Tue, 03 Apr 2018 06:12:37 GMT"  
    7. 
  
  
  
  
  7. content: length:0000000000060"服务端的数据数据:\"Tue, 03 Apr 2018 06:12:42 GMT\"" 64  
    8. 
  
  
  
  
  8. length 60  
    9. 
  
  
  
  
  9. heap.length 60  
    10. 
  
  
  
  
  10. 收到数据 服务端的数据数据:"Tue, 03 Apr 2018 06:12:42 GMT" 
    11.

客户端定时发送自定义协议数据到服务端，先发送头数据，在发送内容数据，另外一个定时器发送心跳数据，服务端判断是心跳数据，再判断是不是头数据，再是内容数据，然后解析后再发送数据给客户端。从日志的打印可以看出客户端先后write header和data数据，服务端可能在一个data事件里面接收到。

这里可以看到一个客户端在同一个时间内处理一个请求可以很好的工作，但是想象这么一个场景，如果同一时间内让同一个客户端去多次调用服务端请求，发送多次头数据和内容数据，服务端的data事件收到的数据就很难区别哪些数据是哪次请求的，比如两次头数据同时到达服务端，服务端就会忽略其中一次，而后面的内容数据也不一定就对应于这个头的。所以想复用长连接并能很好的高并发处理服务端请求，就需要连接池这种方式了。

Socket连接池

什么是Socket连接池,池的概念可以联想到是一种资源的集合，所以Socket连接池，就是维护着一定数量Socket长连接的集合。它能自动检测Socket长连接的有效性，剔除无效的连接，补充连接池的长连接的数量。从代码层次上其实是人为实现这种功能的类，一般一个连接池包含下面几个属性：

  1.  空闲可使用的长连接队列
  2.  正在运行的通信的长连接队列
  3.  等待去获取一个空闲长连接的请求的队列
  4.  无效长连接的剔除功能
  5.  长连接资源池的数量配置
  6.  长连接资源的新建功能

场景： 一个请求过来，首先去资源池要求获取一个长连接资源，如果空闲队列里面有长连接，就获取到这个长连接Socket,并把这个Socket移到正在运行的长连接队列。如果空闲队列里面没有，且正在运行的队列长度小于配置的连接池资源的数量，就新建一个长连接到正在运行的队列去，如果正在运行的不下于配置的资源池长度，则这个请求进入到等待队列去。当一个正在运行的Socket完成了请求，就从正在运行的队列移到空闲的队列，并触发等待请求队列去获取空闲资源，如果有等待的情况。

这里简单介绍Nodejs的Socket连接池generic-pool模块的源码。

主要文件目录结构 

 
 
 
 
    
  
  
  
  
  1. .  
    2. 
  
  
  
  
  2. |————lib  ------------------------- 代码库  
    3. 
  
  
  
  
  3. | |————DefaultEvictor.js ----------   
    4. 
  
  
  
  
  4. | |————Deferred.js ----------------   
    5. 
  
  
  
  
  5. | |————Deque.js -------------------   
    6. 
  
  
  
  
  6. | |————DequeIterator.js -----------   
    7. 
  
  
  
  
  7. | |————DoublyLinkedList.js --------   
    8. 
  
  
  
  
  8. | |————DoublyLinkedListIterator.js-   
    9. 
  
  
  
  
  9. | |————factoryValidator.js --------   
    10. 
  
  
  
  
  10. | |————Pool.js -------------------- 连接池主要代码  
    11. 
  
  
  
  
  11. | |————PoolDefaults.js ------------   
    12. 
  
  
  
  
  12. | |————PooledResource.js ----------   
    13. 
  
  
  
  
  13. | |————Queue.js ------------------- 队列  
    14. 
  
  
  
  
  14. | |————ResourceLoan.js ------------   
    15. 
  
  
  
  
  15. | |————ResourceRequest.js ---------   
    16. 
  
  
  
  
  16. | |————utils.js ------------------- 工具  
    17. 
  
  
  
  
  17. |————test ------------------------- 测试目录  
    18. 
  
  
  
  
  18. |————README.md  ------------------- 项目描述文件  
    19. 
  
  
  
  
  19. |————.eslintrc  ------------------- eslint静态检查配置文件  
    20. 
  
  
  
  
  20. |————.eslintignore  --------------- eslint静态检查忽略的文件  
    21. 
  
  
  
  
  21. |————package.json ----------------- npm包依赖配置 
    22.

下面介绍库的使用：

初始化连接池 

 
 
 
 
    
  
  
  
  
  1. 'use strict';  
    2. 
  
  
  
  
  2. const net = require('net');  
    3. 
  
  
  
  
  3. const genericPool = require('generic-pool');  
    4. 
  
  
  
  
  4. function createPool(conifg) {  
    5. 
  
  
  
  
  5.   let options = Object.assign({  
    6. 
  
  
  
  
  6.     fifo: true,                             // 是否优先使用老的资源  
    7. 
  
  
  
  
  7.     priorityRange: 1,                       // 优先级  
    8. 
  
  
  
  
  8.     testOnBorrow: true,                     // 是否开启获取验证  
    9. 
  
  
  
  
  9.     // acquireTimeoutMillis: 10 * 1000,     // 获取的超时时间  
    10. 
  
  
  
  
  10.     autostart: true,                        // 自动初始化和释放调度启用  
    11. 
  
  
  
  
  11.     min: 10,                                // 初始化连接池保持的长连接最小数量  
    12. 
  
  
  
  
  12.     max: 0,                                 // 最大连接池保持的长连接数量  
    13. 
  
  
  
  
  13.     evictionRunIntervalMillis: 0,           // 资源释放检验间隔检查 设置了下面几个参数才起效果  
    14. 
  
  
  
  
  14.     numTestsPerEvictionRun: 3,              // 每次释放资源数量  
    15. 
  
  
  
  
  15.     softIdleTimeoutMillis: -1,              // 可用的超过了最小的min 且空闲时间时间 达到释放  
    16. 
  
  
  
  
  16.     idleTimeoutMillis: 30000                // 强制释放  
    17. 
  
  
  
  
  17.     // maxWaitingClients: 50                // 最大等待 
    18. 
  
  
  
  
  18.   }, conifg.options);  
    19. 
  
  
  
  
  19.   const factory = {  
    20. 
  
  
  
  
  20.     create: function () {  
    21. 
  
  
  
  
  21.       return new Promise((resolve, reject) => {  
    22. 
  
  
  
  
  22.         let socket = new net.Socket();  
    23. 
  
  
  
  
  23.         socket.setKeepAlive(true); 
    24. 
  
  
  
  
  24.         socket.connect(conifg.port, conifg.host);  
    25. 
  
  
  
  
  25.         // TODO 心跳包的处理逻辑  
    26. 
  
  
  
  
  26.         socket.on('connect', () => {  
    27. 
  
  
  
  
  27.           console.log('socket_pool', conifg.host, conifg.port, 'connect' );  
    28. 
  
  
  
  
  28.           resolve(socket);  
    29. 
  
  
  
  
  29.         });  
    30. 
  
  
  
  
  30.         socket.on('close', (err) => { // 先end 事件再close事件  
    31. 
  
  
  
  
  31.           console.log('socket_pool', conifg.host, conifg.port, 'close', err);  
    32. 
  
  
  
  
  32.         });  
    33. 
  
  
  
  
  33.         socket.on('error', (err) => {  
    34. 
  
  
  
  
  34.           console.log('socket_pool', conifg.host, conifg.port, 'error', err);  
    35. 
  
  
  
  
  35.           reject(err); 
    36. 
  
  
  
  
  36.         });  
    37. 
  
  
  
  
  37.       });  
    38. 
  
  
  
  
  38.     },  
    39. 
  
  
  
  
  39.     //销毁连接  
    40. 
  
  
  
  
  40.     destroy: function (socket) {  
    41. 
  
  
  
  
  41.       return new Promise((resolve) => {  
    42. 
  
  
  
  
  42.         socket.destroy(); // 不会触发end 事件 第一次会触发发close事件 如果有message会触发error事件  
    43. 
  
  
  
  
  43.         resolve();  
    44. 
  
  
  
  
  44.       });  
    45. 
  
  
  
  
  45.     },  
    46. 
  
  
  
  
  46.     validate: function (socket) { //获取资源池校验资源有效性  
    47. 
  
  
  
  
  47.       return new Promise((resolve) => {  
    48. 
  
  
  
  
  48.         // console.log('socket.destroyed:', socket.destroyed, 'socket.readable:', socket.readable, 'socket.writable:', socket.writable);  
    49. 
  
  
  
  
  49.         if (socket.destroyed || !socket.readable || !socket.writable) {  
    50. 
  
  
  
  
  50.           return resolve(false);  
    51. 
  
  
  
  
  51.         } else {  
    52. 
  
  
  
  
  52.           return resolve(true);  
    53. 
  
  
  
  
  53.         }  
    54. 
  
  
  
  
  54.       });  
    55. 
  
  
  
  
  55.     }  
    56. 
  
  
  
  
  56.   };  
    57. 
  
  
  
  
  57.   const pool = genericPool.createPool(factory, options);  
    58. 
  
  
  
  
  58.   pool.on('factoryCreateError', (err) => { // 监听新建长连接出错 让请求直接返回错误  
    59. 
  
  
  
  
  59.     const clientResourceRequest = pool._waitingClientsQueue.dequeue();  
    60. 
  
  
  
  
  60.     if (clientResourceRequest) {  
    61. 
  
  
  
  
  61.       clientResourceRequest.reject(err);  
    62. 
  
  
  
  
  62.     }  
    63. 
  
  
  
  
  63.   });  
    64. 
  
  
  
  
  64.   return pool;  
    65. 
  
  
  
  
  65. };  
    66. 
  
  
  
  
  66. let pool = createPool({  
    67. 
  
  
  
  
  67.   port: 9000,  
    68. 
  
  
  
  
  68.   host: '127.0.0.1',  
    69. 
  
  
  
  
  69.   options: {min: 0, max: 10}  
    70. 
  
  
  
  
  70. }); 
    71.

使用连接池

下面连接池的使用，使用的协议是我们之前自定义的协议。 

 
 
 
 
    
  
  
  
  
  1. let pool = createPool({  
    2. 
  
  
  
  
  2.   port: 9000,  
    3. 
  
  
  
  
  3.   host: '127.0.0.1',  
    4. 
  
  
  
  
  4.   options: {min: 0, max: 10}             
    
                当前标题：一篇搞懂TCP、HTTP、Socket、Socket连接池
                
    
                URL标题：http://www.shufengxianlan.com/qtweb/news21/90521.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容

用户体验知识

分类信息网

h5页面制作　　 　眉山电信机房　　 　东方电机技改　　 　网站空间　　 　网络推广　　 　成都圣月制冷　　 　关键词排名优化　　 　定制网站设计　　 　广元双南建站　　 　德阳网站建设　　 　中国电信成都枢纽中心　　 　云服务器　　 　网络营销　　 　成都移动服务器托管　　 　成都艺考培训　　 　谷歌推广　　 　重庆水土三线托管　　 　成都外贸网站建设公司　　 　广安迈傲建站　　 　wap网站制作