综合转载：socket之KEEPALIVE机制与原理分析

最新推荐文章于 2021-08-13 10:27:39 发布

潇儒瀚

最新推荐文章于 2021-08-13 10:27:39 发布

阅读量677

点赞数

分类专栏： Java Socket

Java Socket 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

在一个正常的TCP连接上，当我们用无限等待的方式调用下面的Recv或Send的时候：

ret=recv(s,&buf[idx],nLeft,flags);

或

ret=send(s,&buf[idx],nLeft,flags);

如果TCP连接被对方正常关闭，也就是说，对方是正确地调用了closesocket(s)或者shutdown(s)的话，那么上面的Recv或Send调用就能马上返回，并且报错。这是由于closesocket(s)或者shutdown(s)有个正常的关闭过程，会告诉对方“TCP连接已经关闭，你不需要再发送或者接受消息了”。但是，如果是网线突然被拔掉，TCP连接的任何一端的机器突然断电或重启动，那么这时候正在执行Recv或Send操作的一方就会因为没有任何连接中断的通知而一直等待下去，也就是会被长时间卡住。这种情形解决的办法

是启动TCP编程里的keepAlive机制。

    struct TCP_KEEPALIVE inKeepAlive = {0};
    unsigned long ulInLen = sizeof(struct TCP_KEEPALIVE);
    struct TCP_KEEPALIVE outKeepAlive = {0};
    unsigned long ulOutLen = sizeof(struct TCP_KEEPALIVE);
    unsigned long ulBytesReturn = 0;

    inKeepAlive.onoff=1;
    inKeepAlive.keepaliveinterval=5000; //单位为毫秒
    inKeepAlive.keepalivetime=1000;      //单位为毫秒
    ret=WSAIoctl(s, SIO_KEEPALIVE_VALS, (LPVOID)&inKeepAlive, ulInLen,

(LPVOID)&outKeepAlive, ulOutLen, &ulBytesReturn, NULL, NULL);

此处的keepalivetime表示的是TCP连接处于畅通时候的探测频率，一旦探测包没有返回，就以keepaliveinterval

的频率发送，经过若干次的重试，如果探测包都没有返回，那么就得出结论：TCP连接已经断开，于是上面的Recv或Send调用也就能马上返回，不会无限制地卡住了。

上图是对上面文字的说明。亮条之前，TCP处于畅通状态，KeepAlive是以1000毫秒(keepalivetime的值)的频率发送探测包，

在发送到第32个探测包的时候，探测包没有返回，于是就以5000毫秒(keepalivetime的值)的频率发送探测包，重发几次后，

探测包都没有返回，于是就得出结论：此TCP连接已经断开了！

对于Win2K/XP/2003，可以从下面的注册表项找到影响整个系统所有连接的keepalive参数：
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]

“KeepAliveTime”=dword:006ddd00
“KeepAliveInterval”=dword:000003e8
“MaxDataRetries”=”5″

对于实用程序来说，2小时的空闲时间太长。因此，我们需要手工开启Keepalive功能并设置合理的Keepalive参数。在XP和

WIN2003系统上，可以针对单独的socket来设置，但是在windows 2000，不能单独设置，如果设置，那么影响是整个系统的所有socket。

LINUX之TCP连接时间----WinSock TCP keepalive的机理及使用 (2011-08-11 11:08:20)转载
标签：杂谈分类： linux
TCP 是面向连接的 , 在实际应用中通常都需要检测对端是否还处于连接中。如果已断开连接，主要分

为以下几种情况：

1.           连接的对端正常关闭，即使用 closesocket 关闭连接。
2.           连接的对端非正常关闭，包括对端异常关闭，网络断开等情况。

       对于第一种情况，很好判断，但是对于第二种情况，可能会要麻烦一些。在网上找到了一些文

章，大致有以下两种解决方法：
? 自己编写心跳包程序
简单的说也就是在自己的程序中加入一条线程，定时向对端发送数据包，查看是否有 ACK ，如果有则连接正常，没有的话则连接断开。
? 使用 TCP 的 keepalive 机制
这个需要在 WinSock 编程时对当前 SOCKET 进行相应设置即可，比较方便。
为了方便起见，我这里采用 keepalive 机制，下面我就以 WinSock 上我实验得到的结果来大致讲一下其机理和使用方法。
首先说一下 keepalive 来判断异常断开的原理，其实 keepalive 的原理就是 TCP 内嵌的一个心跳包。以服务器端为例，如果当前 server 端检测到超过一定时间（默认是 7,200,000 milliseconds ，也就是 2 个小时）没有数据传输，那么会向client 端发送一个 keep-alive packet （该 keep-alive packet 就是 ACK 和当前 TCP 序列号减一的组合），此时 client 端应该为以下三种情况之一：

1. client 端仍然存在，网络连接状况良好。此时 client 端会返回一个 ACK 。 server 端接收到

ACK 后重置计时器，在 2 小时后再发送探测。如果 2 小时内连接上有数据传输，那么在该时间基础上

向后推延 2 个小时。
2. 客户端异常关闭，或是网络断开。在这两种情况下， client 端都不会响应。服务器没有收到对其发出探测的响应，并且在一定时间（系统默认为 1000 ms ）后重复发送 keep-alive packet ，并且重复发送一定次数（ 2000 XP 2003 系统默认为 5 次 , Vista 后的系统默认为 10 次）。
       3. 客户端曾经崩溃，但已经重启。这种情况下，服务器将会收到对其存活探测的响应，但该响应是一个复位，从而引起服务器对连接的终止。（这条摘抄自 http://www.cppblog.com/zhangyq/archive/2010/02/28/108615.html ，我自己并不太明白）。
了解了 keep alive 大致的原理，下来看看在程序中怎么用，怎么设置参数：

view plain
#include <mstcpip.h>
       BOOL bKeepAlive = TRUE;
int nRet = setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
                             (char*)&bKeepAlive, sizeof(bKeepAlive));
if (nRet == SOCKET_ERROR)
{
    TRACE(L"setsockopt failed: %d/n", WSAGetLastError());
    return FALSE;
}
// set KeepAlive parameter
tcp_keepalive alive_in;
tcp_keepalive alive_out;
alive_in.keepalivetime    = 500; // 0.5s
alive_in.keepaliveinterval = 1000; //1s
alive_in.onoff                       = TRUE;
unsigned long ulBytesReturn = 0;
nRet = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &alive_in, sizeof(alive_in),
                  &alive_out, sizeof(alive_out), &ulBytesReturn, NULL, NULL);
if (nRet == SOCKET_ERROR)
{
    TRACE(L"WSAIoctl failed: %d/n", WSAGetLastError());
    return FALSE;
}

其中， setsockopt 设置了 keepalive 模式，但是系统对 keepalive 默认的参数可能不符合我们的要求，比如空闲 2 小时后才探测对端是否活跃，所以 WSAIoctl 函数通过 tcp_keepalive 结构体对这些参数进行了相应设置。 tcp_keepalive 这个结构体在 mstcpip.h 头文件中有定义：
    struct tcp_keepalive {
        ULONG onoff ;   // 是否开启 keepalive
        ULONG keepalivetime ; // 多长时间（ ms ）没有数据就开始 send 心跳包
ULONG keepaliveinterval ; // 每隔多长时间（ ms ） send 一个心跳包，
// 发 5 次 (2000 XP 2003 默认 ), 10 次 (Vista 后系统默认 )
};
这个结构体设置了空闲检测时间，及检测时重复发送的间隔时间。详细的可以查询 msdn : http://msdn.microsoft.com/en-us/library/dd877220(VS.85).aspx 。按照 msdn 上的说法，这些参数也可以通过在注册表里设置，分别为：
HKLM/SYSTEM/CurrentControlSet/Services/Tcpip/Parameters/KeepAliveTime
HKLM/SYSTEM/CurrentControlSet/Services/Tcpip/Parameters/KeepAliveInterval

另外，有些人可能已经发现了， tcp_keepalive 这个结构体中没有对重试次数这个参数的设置，这个参数可以通过注册表来设置，具体位置为：
HKLM/SYSTEM/CurrentControlSet/Services/Tcpip/Parameters/TcpMaxDataRetransmissions
关于在注册表中设置这几个参数，我在 XP 和 Server2008 系统中都没有找到， msdn 上说貌似只是支持 server 2003 ，我这里没有实验，具体不太清楚。

设置好 keepalive 以后，我们通过实验来看看当 client 异常退出或是网络断掉的情况下，

keepalive 怎么通知我们异常断开的情况。这里采用 select 模式，实验环境为 XP 系统和 Win7 系统，几种情况返回值如下：
1．正常断开
select 函数正常返回， recv 函数返回 0
2．异常断开
a) 程序异常退出，如 client 端重启，应用非正常关闭等
select 函数正常返回， recv 函数返回 SOCKET_ERROR ， WSAGetLastError () 得到的结果为 WSAECONNRESET(10054) 。
b) 网络断开
结果同上： select 函数正常返回， recv 函数返回 SOCKET_ERROR ， WSAGetLastError() 得到的结果为 WSAECONNRESET(10054) 。
P.S. 网上有些文章中写的 WSAGetLastError() 得到的结果为 ETIMEDOUT ，我这里不太清楚为什么和

我这里得到的不太一样。

另外，在实验中，我发现了一个和以前理解的不太相同的地方，在这里也记录下来：
对于程序异常退出的情况（这里所说的异常退出包括程序异常关闭、重启等情况，但不包括系统待机休眠），实际上在不开启 keepalive 的情况下也是可以检测到的，我这里测试得到在不开启 keepalive 的情况下，异常关闭 client 端程序， server 端 recv 函数会立即返回 SOCKET_ERROR ， last error 同样为 WSAECONNRESET 。但是对于网络断开及系统待机休眠的情况，则必须设置 keepalive 才能检测到，并且对于上述情况，当网络重新连接或者系统恢复后，SOCKET连接并不能恢复。
具体原因我这里也不太清楚，看到有一篇文章是这样写的：“异常关闭下， SOCKET 虚拟通路会被重设，远端正在接受的调用就都会失败”。不知道正确与否，感觉有一定的道理，暂时记录下来。

[转载]服务端程序的keeplive (2011-08-11 11:06:46)转载原文
标签：转载分类： linux
原文地址：服务端程序的keeplive作者：天涯孤客
转载自：http://blog.csdn.net/vincent2600/archive/2010/12/01/6046858.aspx
首先就看一下KeepAlive出现的原因吧：
当一个客户端向服务器发送http请求时，两者之间会建立一个tcp连接，然后服务器发回响应信息同时关闭连接。如果请求的的页面中含有别的资源连接，比如图片、flsah等，就会再次创建连接。KeepAlive的作用就是在第一次创建连接时，服务器会把这个tcp连接保持一段时间（服务器端会有一个keepaliveTime的最大时间，超过时间就断开连接）。这样就不会频繁的去建立tcp连接，同一次请求中的信息传递都可以使用同一个tcp连接。

KeepAlive的工作原理：
在HTTP1.0和HTTP1.1协议中都有对KeepAlive的支持。其中HTTP1.0需要在request中增加“Connection： keep-alive” header才能够支持，而HTTP1.1默认支持。（大家可以利用抓包工具看一下） HTTP1.0 KeepAlive支持的数据交互流程如下：
a)Client发出request，其中该request的HTTP版本号为1.0。同是在request中包含一个header：

“Connection： keep-alive”。
b)Web Server收到request中的HTTP协议为1.0及“Connection： keep-alive”就认为是一个长连接请求，其将在response的header中也增加“Connection： keep-alive”。同是不会关闭已建立的tcp连接。
c)Client收到Web Server的response中包含“Connection： keep-alive”，就认为是一个长连接，不close tcp连接。并用该tcp连接再发送request。（跳转到a)）
HTTP1.1 KeepAlive支持的数据交互流程如下：
a)Client发出request，其中该request的HTTP版本号为1.1。
b)Web Server收到request中的HTTP协议为1.1就认为是一个长连接请求，其将在response的header中也增加“Connection： keep-alive”。同是不会关闭已建立的tcp连接。
c)Client收到Web Server的response中包含“Connection： keep-alive”，就认为是一个长连接，不close tcp连接。并用该tcp连接再发送request。（跳转到a)）

关于KeepAlive的分析：
现在的一些服务器都可以设置KeepAlive是否开启，以及KeepAlive的超时时间，服务器支持的KeepAlive数量（数量一般不会很大，否则会对服务器产生很大的压力）。
那么我们考虑3种情况：
　　1、用户浏览一个网页时，除了网页本身外，还引用了多个 javascript 文件，多个 css 文件，多个图片文件，并且这些文件都在同一个 HTTP 服务器上。
　　2、用户浏览一个网页时，除了网页本身外，还引用一个 javascript 文件，一个图片文件。
　　3、用户浏览的是一个动态网页，由程序即时生成内容，并且不引用其他内容。
对于上面3中情况，1 最适合打开 KeepAlive ，2 随意，3 最适合关闭 KeepAlive 打开 KeepAlive 后，意味着每次用户完成全部访问后，都要保持一定时间后才关闭会关闭 TCP 连接，那么在关闭连接之前，必然会有一个服务器进程对应于该用户而不能处理其他用户，假设 KeepAlive 的超时时间为 10 秒种，服务器每秒处理 50 个独立用户访问，那么系统中 Apache 的总进程数就是

10 * 50 ＝ 500 个，如果一个进程占用 4M 内存，那么总共会消耗 2G 内存，所以可以看出，在这种配置中，相当消耗内存，但好处是系统只处理了 50次 TCP 的握手和关闭操作。
如果关闭 KeepAlive，如果还是每秒50个用户访问，如果用户每次连续的请求数为3个，那么 Apache 的总进程数就是 50 * 3 = 150 个，如果还是每个进程占用 4M 内存，那么总的内存消耗为 600M，这种配置能节省大量内存，但是，系统处理了 150 次 TCP 的握手和关闭的操作，因此又会多消耗一些 CPU 资源。

采用TCP连接的C/S模式软件，连接的双方在连接空闲状态时，如果任意一方意外崩溃、当机、网线断开或路由器故障，另一方无法得知TCP连接已经失效，除非继续在此连接上发送数据导致错误返回。很多时候，这不是我们需要的。我们希望服务器端和客户端都能及时有效地检测到连接失效，然后优雅地完成一些清理工作并把错误报告给用户。

如何及时有效地检测到一方的非正常断开，一直有两种技术可以运用。一种是由TCP协议层实现的Keepalive，另一种是由应用层自己实现的心跳包。TCP默认并不开启Keepalive功能，因为开启Keepalive功能需要消耗额外的宽带和流量，尽管这微不足

道，但在按流量计费的环境下增加了费用，另一方面，Keepalive设置不合理时可能会因为短暂的网络波动而断开健康的TCP连接。并且，默认的Keepalive超时需要7,200,000 milliseconds，即2小时，探测次数为5次。对于Win2K/XP/2003，可以从下面的注册表项找到影响整个系统所有连接的keepalive参数：

view plaincopy to clipboardprint?
[HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesTcpipParameters]
“KeepAliveTime”=dword:006ddd00
“KeepAliveInterval”=dword:000003e8
“MaxDataRetries”=”5″

对于实用的程序来说，2小时的空闲时间太长。因此，我们需要手工开启Keepalive功能并设置合理的Keepalive参数。

view plaincopy to clipboardprint?
// 开启KeepAlive
BOOL bKeepAlive = TRUE;
int nRet = ::setsockopt(socket_handle, SOL_SOCKET, SO_KEEPALIVE, (char*)&bKeepAlive, sizeof(bKeepAlive));
if (nRet == SOCKET_ERROR)
{
return FALSE;
}
// 设置KeepAlive参数
tcp_keepalive alive_in                = {0};
tcp_keepalive alive_out                = {0};
alive_in.keepalivetime                = 5000;                // 开始首次KeepAlive探测前的

TCP空闭时间
alive_in.keepaliveinterval        = 1000;                // 两次KeepAlive探测间的时间间隔
alive_in.onoff                                = TRUE;
unsigned long ulBytesReturn = 0;
nRet = WSAIoctl(socket_handle, SIO_KEEPALIVE_VALS, &alive_in, sizeof(alive_in), &alive_out, sizeof(alive_out), &ulBytesReturn, NULL, NULL);
if (nRet == SOCKET_ERROR)
{
return FALSE;
}

开启Keepalive选项之后，对于使用IOCP模型的服务器端程序来说，一旦检测到连接断开，GetQueuedCompletionStatus函数将立即返回FALSE，使得服务器端能及时清除该连接、释放该连接相关的资源。对于使用select模型的客户端来说，连接断开被探测到时，以recv目的阻塞在socket上的select方法将立即返回SOCKET_ERROR，从而得知连接已失效，客户端程序便有机会及时执行清除工作、提醒用户或重新连接。

另一种技术，由应用程序自己发送心跳包来检测连接的健康性。客户端可以在一个Timer中或低级别的线程中定时向发服务器发送一个短小精悍的包，并等待服务器的回应。客户端程序在一定时间内没有收到服务器回应即认为连接不可用，同样，服务器在一定时间内没有收到客户端的心跳包则认为客户端已经掉线。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

windows下此处的”非正常断开”指TCP连接不是以优雅的方式断开,如网线故障等物理链路的原因,还有突然主机断电等原因.

有两种方法可以检测:

1.TCP连接双方定时发握手消息

2.利用TCP协议栈中的KeepAlive探测
第二种方法简单可靠,只需对TCP连接两个Socket设定KeepAlive探测,
所以本文只讲第二种方法在Linux,Window2000下的实现(在其它的平台上没有作进一步的测试)Windows 2000平台下头文件

view plaincopy to clipboardprint?
#include <mstcpip.h>
//定义结构及宏
struct TCP_KEEPALIVE {
u_longonoff;
u_longkeepalivetime;
u_longkeepaliveinterval;
} ;
tcp_keepalive live,liveout;
live.keepaliveinterval=500;
live.keepalivetime=3000;
live.onoff=TRUE;
int iRet = setsockopt(Socket,SOL_SOCKET,SO_KEEPALIVE,(char *)Opt,sizeof(int));
if(iRet == 0){
     DWORD dw;
    if(WSAIoctl(Socket,SIO_KEEPALIVE_VALS,
        &live,sizeof(live),&liveout,sizeof(liveout),
        &dw,NULL,NULL)== SOCKET_ERROR){
               //Delete Client
               return;
     }
}

ACE下代码 //by rainfish    blog.csdn.net/bat603

view plaincopy to clipboardprint?
int Opt = 1;
//在测试过程中，发现检测的次数是5次，即下面的设置中，从最近一次消息开始计算的10秒后，每次间隔5秒，连续发送5次，即35秒发现网络断了
tcp_keepalive live,liveout;
live.keepaliveinterval=5000; //每次检测的间隔（单位毫秒）
live.keepalivetime=10000; //第一次开始发送的时间（单位毫秒）
live.onoff=TRUE;
int iRet = stream.set_option(SOL_SOCKET,SO_KEEPALIVE,&Opt,sizeof(int));
if(iRet == 0){
     DWORD dw;
     //此处显示了在ACE下获取套接字的方法，即句柄的(SOCKET)化就是句柄
    if(WSAIoctl((SOCKET)h,SIO_KEEPALIVE_VALS,&live,sizeof(live),
        &liveout,sizeof(liveout),&dw,NULL,NULL)== SOCKET_ERROR){
         //Delete Client
         return;
     }
}

Linux平台下

view plaincopy to clipboardprint?
#include    "/usr/include/linux/tcp.h"
#include "/usr/include/linux/socket.h"
KeepAlive实现，单位秒
//下面代码要求有ACE,如果没有包含ACE,则请把用到的ACE函数改成linux相应的接口
int keepAlive = 1;//设定KeepAlive
int keepIdle = 5;//开始首次KeepAlive探测前的TCP空闭时间
int keepInterval = 5;//两次KeepAlive探测间的时间间隔
int keepCount = 3;//判定断开前的KeepAlive探测次数
if(setsockopt(s,SOL_SOCKET,SO_KEEPALIVE,(void*)&keepAlive,sizeof(keepAlive)) == -1)
{
    ACE_DEBUG ((LM_INFO,
    ACE_TEXT ("(%P|%t) setsockopt SO_KEEPALIVE error!n")));
}
if(setsockopt(s,SOL_TCP,TCP_KEEPIDLE,(void *)&keepIdle,sizeof(keepIdle)) == -1)
{
    ACE_DEBUG ((LM_INFO,
    ACE_TEXT ("(%P|%t) setsockopt TCP_KEEPIDLE error!n")));
}
if(setsockopt(s,SOL_TCP,TCP_KEEPINTVL,(void *)&keepInterval,sizeof(keepInterval)) == -1)
{
    ACE_DEBUG ((LM_INFO,
    ACE_TEXT ("(%P|%t) setsockopt TCP_KEEPINTVL error!n")));
}
if(setsockopt(s,SOL_TCP,TCP_KEEPCNT,(void *)&keepCount,sizeof(keepCount)) == -1)
{
    ACE_DEBUG ((LM_INFO,
    ACE_TEXT ("(%P|%t)setsockopt TCP_KEEPCNT error!n")));
}

潇儒瀚

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
综合转载：socket之KEEPALIVE机制与原理分析

在一个正常的TCP连接上，当我们用无限等待的方式调用下面的Recv或Send的时候： ret=recv(s,&buf[idx],nLeft,flags); 或 ret=send(s,&buf[idx],nLeft,flags); 如果TCP连接被对方正常关闭，也就是说，对方是正确地调用了closesocket(s)或者shutdown(s)的话，那么
复制链接

扫一扫