网络编程中的TCP保活

最新推荐文章于 2023-09-29 01:30:54 发布
最新推荐文章于 2023-09-29 01:30:54 发布
阅读量1.6k 收藏 4
点赞数
分类专栏： 网络

在默认的情况下，TCP连接是没有保活的心跳的。这就是说，当一个TCP的socket，客户端与服务端谁也不发送数据，会一直保持着连接。这其中如果有一方异常掉线，另一端永远也不可能知道。这对于一些服务型的程序来说，将是灾难性的后果。

　　所以，必须对创建的socket，启用保活心跳，即Keepalive选项。

启用Keepalive

　　对于WIN32或者Linux平台来说，设置socket的Keepalive都很简单，只需使用setsockopt设置SO_KEEPALIVE即可。

　　setsockopt的函数原型在Linux环境下为：

[html]  view plain copy
  1. #include <sys/types.h>    
  2. #include <sys/socket.h>    
  3.     
  4. int setsockopt(int s, int level, int optname,    
  5.                const void *optval,    
  6.                socklen_t optlen);    
，在WIN32平台下为

[html]  view plain copy
  1. #include <winsock2.h>    
  2.     
  3. int setsockopt(int s, int level, int optname,    
  4.                const char *optval,    
  5.                int optlen);    

　　因为const void *可以接受const char *型的参数，所以为了代码的跨平台编译考虑，可以采用以下代码来设置TCP的Keepalive选项。

[html]  view plain copy
  1. alive = 1;  
  2. if (setsockopt  
  3.     (fd, SOL_SOCKET, SO_KEEPALIVE, (const char *) &alive,  
  4.      sizeof alive) != 0)  
  5.   {  
  6.     log_warn ("Set keep alive error: %s.\n", strerror (errno));  
  7.     return -1;  
  8.   }  

　　这样，对于TCP的连接，就启用了系统默认值的保活心跳。


Linux环境下的TCP Keepalive参数设置

　　为什么说是系统默认值的呢？因为有这样几个值，我们并没有手动设置，是采用的系统默认值。即，

  1. 多长时间发送一次保活心跳？
  2. 如果没有返回，多长时间再重试发送？
  3. 重试几次为失败？

    　　如果是Linux操作系统，这三个值分别为

    [html]  view plain copy
    1. # cat /proc/sys/net/ipv4/tcp_keepalive_time    
    2. 7200    
    3. # cat /proc/sys/net/ipv4/tcp_keepalive_intvl    
    4. 75    
    5. # cat /proc/sys/net/ipv4/tcp_keepalive_probes    
    6. 9    

　　这就是说，在Linux系统下，如果对于TCP的socket启用了Keepalive选项，则会在7200秒（即两个小时）没有数据后，发起KEEPALIVE报文。如果没有回应，则会在75秒后再次重试。如果重试9次均失败，则认定连接已经失效。TCP的读取操作，将返回0。

　　这对于我们大多数应用来说，前两个时间值都有点太长了。

　　我们可以通过重设上面三个值，来使得操作系统上运行的所有启用了Keepalive选项的TCP的socket的行为更改。

　　我们也可以只针对我们自己创建的socket，重设这三个值。它们分别对应TCP_KEEPIDLE、TCP_KEEPINTL和TCP_KEEPCNT的选项值，同样可以使用setsockopt进行设置。

[html]  view plain copy
  1. #include <stdlib.h>    
  2. #include <fcntl.h>    
  3. #include <errno.h>    
  4. #include <sys/socket.h>    
  5. #include <netinet/tcp.h>    
  6. #include <netinet/in.h>    
  7. #include <netdb.h>    
  8. #include <arpa/inet.h>    
  9.     
  10. int    
  11. socket_set_keepalive (int fd)    
  12. {    
  13.   int ret, error, flag, alive, idle, cnt, intv;    
  14.     
  15.   /* Set: use keepalive on fd */    
  16.   alive = 1;    
  17.   if (setsockopt    
  18.       (fd, SOL_SOCKET, SO_KEEPALIVE, &alive,    
  19.        sizeof alive) != 0)    
  20.     {    
  21.       log_warn ("Set keepalive error: %s.\n", strerror (errno));    
  22.       return -1;    
  23.     }    
  24.     
  25.   /* １０秒钟无数据，触发保活机制，发送保活包 */    
  26.   idle = 10;    
  27.   if (setsockopt (fd, SOL_TCP, TCP_KEEPIDLE, &idle, sizeof idle) != 0)    
  28.     {    
  29.       log_warn ("Set keepalive idle error: %s.\n", strerror (errno));    
  30.       return -1;    
  31.     }    
  32.     
  33.   /* 如果没有收到回应，则５秒钟后重发保活包 */    
  34.   intv = 5;    
  35.   if (setsockopt (fd, SOL_TCP, TCP_KEEPINTVL, &intv, sizeof intv) != 0)    
  36.     {    
  37.       log_warn ("Set keepalive intv error: %s.\n", strerror (errno));    
  38.       return -1;    
  39.     }    
  40.     
  41.   /* 连续３次没收到保活包，视为连接失效 */    
  42.   cnt = 3;    
  43.   if (setsockopt (fd, SOL_TCP, TCP_KEEPCNT, &cnt, sizeof cnt) != 0)    
  44.     {    
  45.       log_warn ("Set keepalive cnt error: %s.\n", strerror (errno));    
  46.       return -1;    
  47.     }    
  48.     
  49.   return 0;    
  50. }    

WIN32环境下的TCP Keepalive参数设置

　　而WIN32环境下的参数设置，就要麻烦一些，需要使用另外的一个函数WSAIoctl和一个结构struct tcp_keepalive。

　　它们的原型分别为：

[html]  view plain copy
  1. #include <winsock2.h>    
  2. #include <mstcpip.h>    
  3.     
  4. int WSAIoctl(    
  5.              SOCKET s,    
  6.              DWORD dwIoControlCode,    
  7.              LPVOID lpvInBuffer,    
  8.              DWORD cbInBuffer,    
  9.              LPVOID lpvOutBuffer,    
  10.              DWORD cbOutBuffer,    
  11.              LPDWORD lpcbBytesReturned,    
  12.              LPWSAOVERLAPPED lpOverlapped,    
  13.              LPWSAOVERLAPPED_COMPLETION lpCompletionRoutine    
  14. );    
  15.     
  16. struct tcp_keepalive {    
  17.     u_long onoff;    
  18.     u_long keepalivetime;    
  19.     u_long keepaliveinterval;    
  20. };    
　　在这里，使用WSAIoctl的时候，dwIoControlCode要使用SIO_KEEPALIVE_VALS，lpvOutBuffer用不上，cbOutBuffer必须设置为0。

　　struct tcp_keepalive结构的参数意义为：

　　onoff，是否开启KEEPALIVE； keepalivetime，多长时间触发Keepalive报文的发送； keepaliveinterval，多长时间没有回应触发下一次发送。

　　注意：这里两个时间单位都是毫秒而不是秒。

[html]  view plain copy
  1. #include <winsock2.h>    
  2. #include <mstcpip.h>    
  3.     
  4. int    
  5. socket_set_keepalive (int fd)    
  6. {    
  7.   struct tcp_keepalive kavars[1] = {    
  8.       1,    
  9.       10 * 1000,        /* 10 seconds */    
  10.       5 * 1000          /* 5 seconds */    
  11.   };    
  12.     
  13.   /* Set: use keepalive on fd */    
  14.   alive = 1;    
  15.   if (setsockopt    
  16.       (fd, SOL_SOCKET, SO_KEEPALIVE, (const char *) &alive,    
  17.        sizeof alive) != 0)    
  18.     {    
  19.       log_warn ("Set keep alive error: %s.\n", strerror (errno));    
  20.       return -1;    
  21.     }    
  22.     
  23.   if (WSAIoctl    
  24.       (fd, SIO_KEEPALIVE_VALS, kavars, sizeof kavars, NULL, sizeof (int), &ret, NULL,    
  25.        NULL) != 0)    
  26.     {    
  27.       log_warn ("Set keep alive error: %s.\n", strerror (WSAGetLastError ()));    
  28.       return -1;    
  29.     }    
  30.     
  31.   return 0;    
  32. }   


http://blog.csdn.net/weiwangchao_/article/details/7225338


一、问题起因：
a》
在文章：http://tldp.org/HOWTO/html_single/TCP-Keepalive-HOWTO/  写到：
There are also three other socket options you can set for keepalive when you write your application. 
They all use the SOL_TCP  level instead of SOL_SOCKET, and they override system-wide variables 
only for the current socket. If you read without writing first, 
the current system-wide parameters will be returned.

TCP_KEEPCNT:     overrides tcp_keepalive_probes
TCP_KEEPIDLE:     overrides tcp_keepalive_time
TCP_KEEPINTVL:     overrides tcp_keepalive_intvl

上面说：设置 socket 的keepalive 属性选项, 只对当前socket起作用
-----they override system-wide variables only for the current socket。

b》
可是：《TCP/IP详解 卷1：协议》page 252 中写到：
“一个被人们不断讨论的关于保活选项的问题就是两个小时的空闲时间是否可以改
变。通常他们希望该数值可以小得多，处在分钟的数量级。正如我们在附录E看到的，
这个值通常可以改变，但是在该附录所描述的所有系统中，保活间隔时间是系统级的
变量，因此改变它会影响到所有使用该功能的用户。
Host Requirements RFC提到一个实现可提供保活的功能，但是除非应用程序指明
要这样，否则就不能使用该功能。而且，保活间隔必须是可配置的，但是其默认值必
须不小于两个小时。”

我的理解是：这里两处的描述，有些矛盾。
到底 keepalive 属性是只对单个socket起作用，还是会影响其他socket？
为此，用来下面的程序来测试。

在下面的程序中，在服务器端使用TCP保活选项，客户端没有使用。
客户端也可以使用这个选项，但通常都是服务器设置这个功能。
如果双方都特别需要了解对方是否已经消失，则双方都可以使用这个选项。

这个程序写的比较简单： 
没有考虑服务器效率，只是为了测试 keepalive 属性。
错误处理也都非常简单。

说明：本文只是测试客户主机崩溃或者网络异常断开，比如拔掉网线 或 中间路由器崩溃等情况。
正常关机或重启本文不予考虑。

思路:
在程序中表现为,当tcp检测到对端socket不再可用时(TCP发出保活探查报文，但是没有收到客户端对其保活探查报文的响应), select会返回socket可读, 并且在 recv 或 read 时返回-1,
同时设置errno为 ETIMEDOUT。

服务器端：

#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>

#define SRV_PORT 12345
#define LISTEN_QUEUE 20

#define CONN_MAX 1024

/* 存放已连接的客户端描述符 */

int conn[CONN_MAX];

/* 当前已连接客户端的总数 */
int conn_amount;

int init_socket_tcp(unsigned short port, int backlog);
void active_keepalive(int sockfd);
void set_keepalive_params(int sockfd, int idle, int count, int intvl);

static int firstclient = 1;

int main(int argc, char *argv[])
{
    int sockfd, cltfd = -1;
    struct sockaddr_in clt_addr;
    socklen_t addrlen;
    
    int i, n;
    char buf[1024];
    int len;

    int maxfd;
    fd_set readfds;

    sockfd = init_socket_tcp(SRV_PORT, LISTEN_QUEUE);
    if (sockfd < 0) {
        perror("init socket failed!");
        exit(EXIT_FAILURE);
    }

    for (i = 0; i < CONN_MAX; i++) {
            conn[i] = -1;
    }

    maxfd = sockfd;
    conn_amount = 0;

    while (1) {
        FD_ZERO(&readfds);
        FD_SET(sockfd, &readfds);
    
        for (i = 0; i < CONN_MAX; i++) {
            if (conn[i] != -1) {
                FD_SET(conn[i], &readfds);
                if (conn[i] > maxfd)
                    maxfd = conn[i];
            }
        }

        printf("start select............\n");
        if ((n = select(maxfd + 1, &readfds, NULL, NULL, NULL)) < 0) {
            perror("select faield");
            continue;
        }
        
        for (i = 0; i < CONN_MAX; i++) {
            if ((conn[i] != -1) && FD_ISSET(conn[i], &readfds)) {
                len = read(conn[i], buf, sizeof(buf) - 1);
                if (len < 0) {
                    if (errno == EINTR) {
                        printf("errno == EINTR\n");
                        continue;
                    }
                    if (errno == ETIMEDOUT)
                        printf("ETIMEDOUT..............., client: %d\n", i + 1);
                    perror("read error");
                    close(conn[i]);
                    conn[i] = -1;
                    conn_amount--;
                } else if (len == 0) {
                        printf("client close socket.\n");
                        close(conn[i]);
                        conn[i] = -1;
                        conn_amount--;
                } else
                    printf("read from client: %s\n", buf);
            }
        } /* for (i = 0; i < CONN_MAX; i++)*/

        if (FD_ISSET(sockfd, &readfds)) {
            addrlen = sizeof(struct sockaddr_in);
            cltfd = accept(sockfd, (struct sockaddr *)&clt_addr, &addrlen);
            if (cltfd < 0) {
                perror("accept failed");
                continue;
            }
        
            if (conn_amount < CONN_MAX) {
                conn_amount++;
                printf("*********** conn_amount = %d\n", conn_amount);
                
                /* set tcp_keepalive_* options */
                /* 设置第一个客户端socket keepalive 属性 */

                if (firstclient) {

                    /* 开启 keepalive 选项 */
                    active_keepalive(cltfd);
                    /* 设置 keepalive 相关参数 */

                    set_keepalive_params(cltfd, 60, 3, 2);
                    firstclient = 0;
                } else { /* 设置其他客户端socket keepalive 属性 */

                    /* 开启 keepalive 选项 */

                    active_keepalive(cltfd);

                    /* 设置 keepalive 相关参数 */
                    set_keepalive_params(cltfd, 20, 3, 5);
                }

                for (i = 0; i < CONN_MAX; i++) {
                    if (conn[i] == -1) {
                        conn[i] = cltfd;
                        break;
                    }
                }
            } else { /* 到达 CONN_MAX后，不处理其他客户端连接请求 */
                printf("max connection arrived, I will close the client socket!\n");
                close(cltfd);
            }
        }

    } /* while (1) */

    close(sockfd);
    exit(EXIT_SUCCESS);
}

int init_socket_tcp(unsigned short port, int backlog)
{
    int sockfd;
    struct sockaddr_in srv_addr;
    socklen_t addrlen;

    sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockfd < 0) {
        perror("create socket failed!");
        return -1;
    }
    
    addrlen = sizeof(struct sockaddr_in);
    memset(&srv_addr, 0, sizeof(struct sockaddr_in));
    srv_addr.sin_family = AF_INET;
    srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    srv_addr.sin_port = htons(port);

    int reuse = 1;
    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int)) < 0) {
        perror("setsockopt SO_REUSEADDR");
        close(sockfd);
        return -1;
    }

    if (bind(sockfd, (struct sockaddr *)&srv_addr, addrlen) < 0) {
        perror("bind errror");
        close(sockfd);
        return -1;
    }
    
    if (listen(sockfd, backlog) < 0) {
        perror("listen error");
        close(sockfd);
        return -1;
    }

    return sockfd;
}

void active_keepalive(int sockfd)
{
    int optval;
    socklen_t optlen = sizeof(optval);

    /* check the status for the keepalive option */
    if (getsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, &optlen) < 0) {
        perror("getsockopt SO_KEEPALIVE failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    printf("SO_KEEPALIVE is %s\n", optval ? "ON" : "OFF");

    /* set the option active */
    optval = 1;
    optlen = sizeof(optval);
    if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, optlen) < 0) {
        printf("setsockopt SO_KEEPALIVE failed，reason: %m\n");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    printf("SO_KEEPALIVE on socket\n");

    /* check the status again */
    if (getsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, &optlen) < 0) {
        perror("getsockopt SO_KEEPALIVE again failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    printf("SO_KEEPALIVE is %s\n", (optval ? "ON" : "OFF"));
}

void set_keepalive_params(int sockfd, int idle, int count, int intvl)
{
    int keepalive_time = idle;
    int keepalive_probes = count;
    int keepalive_intvl = intvl;
    
    if (setsockopt(sockfd, SOL_TCP, TCP_KEEPIDLE, &keepalive_time, sizeof(int)) < 0) {
        perror("TCP_KEEPIDLE failed");
        return;
    }
    
    if (setsockopt(sockfd, SOL_TCP, TCP_KEEPCNT, &keepalive_probes, sizeof(int)) < 0) {
        perror("TCP_KEEPCNT failed");
        return;
    }

    if (setsockopt(sockfd, SOL_TCP, TCP_KEEPINTVL, &keepalive_intvl, sizeof(int)) < 0) {
        perror("TCP_KEEPINTVL failed");
        return;
    }

    return;
}




客户端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>

#define SRV_IP "192.168.1.4"
#define SRV_PORT 12345

#define errexit(msg) do {perror(msg); exit(EXIT_FAILURE);} while(0)

int main(int argc, char *argv[])
{
    int sockfd;
    struct sockaddr_in srvaddr;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
        errexit("socket");
    
    memset(&srvaddr, 0, sizeof(struct sockaddr_in));    
    srvaddr.sin_family = AF_INET;
    srvaddr.sin_addr.s_addr = inet_addr(SRV_IP);
    srvaddr.sin_port = htons(SRV_PORT);

    if (connect(sockfd, (struct sockaddr *)&srvaddr, sizeof(struct sockaddr_in)) != 0)
        errexit("connect");
    else
        printf("connect to server succeeded!\n");

    /* 连接成功后，什么也不做 */
    pause();

    close(sockfd);
    exit(0);
}



测试过程简单描述：
1.启动服务器端程序
2.启动 2 个客户端
3.在2个客户端都成功连接服务器后，断开服务器主机的网线
4.似乎在 20+/-10 秒后，成功检测出客户端 2 断开了，然后似乎再经过 30+/- 10 秒左右, 检测到客户端 1 断开连接。（自己口头数的秒，具体时间很不准确，但不影响结论   ）。

最后的结论：
they override system-wide variables only for the current socket 应该是对的。
也就是，keepalive 属性只对单个socket 起作用，
对其他 socket 的 keepalive 属性没有影响.

http://blog.chinaunix.net/uid-15084954-id-190356.html

bytxl
关注
专栏目录
TCP保活定时器的使用
04-03
在Linux系统中，C语言编程时可以利用内核提供的接口来设置和管理TCP保活定时器，以及相关的IP选项。下面将详细介绍TCP保活定时器的原理、用途以及如何在C程序中进行设置。 1. **TCP保活定时器原理** TCP保活...
【计算机网络】TCP的保活机制
自律带来自由
08-12 962
#笔记整理 TCP 保活机制 一些情况下，客户端和服务器需要了解什么时候终止进程或者与对方断开连接。应用进程之间没有任何数据交换，但仍然需要通过连接保持一个最小的数据流。TCP 保活机制即为了解决上述两种情况而设计。保活机制是一种在不影响数据流内容的情况下探测对方的方式。 它是由一个保活计时器实现的，当计时器被激发，连接一端将发送一个保活探测(简称保活)报文，另一端接收报文的同时会发送一个ACK作...
setsockopt getsockopt 对网络设置的使用
lishenglong666的专栏
09-27 811
1.closesocket（一般不会立即关闭而经历TIME_WAIT的过程）后想继续重用该socket： BOOL bReuseaddr=TRUE; setsockopt (s,SOL_SOCKET ,SO_REUSEADDR,(const char*)&bReuseaddr,sizeof(BOOL)); 2.如果要已经处于连接状态的soket在调用closesocket后强制关闭，不经
WinSock TCP keepalive的机理及使用
冷月醉雪的博客
05-13 516
查看更多 https://www.yuque.com/docs/share/621c665f-aa1d-485d-98c6-35e70e2abb00
socket之KEEPALIVE机制与原理分析
rethyx的专栏
02-25 9762
LINUX之TCP连接时间----TCP keepAlive 详解 (2011-08-11 11:07:04)转载 标签： 杂谈 分类： linux 在一个正常的TCP连接上，当我们用无限等待的方式调用下面的Recv或Send的时候：    ret=recv(s,&buf[idx],nLeft,flags);    或    ret=send(s,&buf[idx],nLef
Linux系统中TCP保持活动（keepalive）属性分析与编程
最新发布
TechRoar的博客
09-29 450
然后，我们调用enable_tcp_keepalive()函数，将TCP keepalive选项设置为套接字。接下来，我们使用poll()函数来等待套接字上的事件发生。上述代码中，我们首先使用setsockopt()函数将SO_KEEPALIVE选项设置为1，以启用TCP keepalive。然后，我们使用poll()函数检测套接字上的事件，以确定是否发生TCP keepalive事件。我们可以使用poll()或select()函数来检测套接字上的事件，以确定是否有TCP keepalive事件发生。
心跳机制tcp keepalive的讨论、应用及“断网”、“断电“检测的C代码实现(Windows环境下)
热门推荐
认知 行动 坚持
04-13 2万+
说明： 1. 本文的讨论和实验都以Windows为例， 其实在linux上也大同小异。 2. 在第一次写此博文时， 我对某些地方有一些误解， 现予以更正， 对文章结构做了较大调整，也欢迎大家提出质疑。 3. 在做实验玩代码的时候， 意料之中地发现腾讯QQ也在玩心跳， 不清楚具体怎么实现的， 但有点意思哈。
C语言编程实现tcp客户端
08-27
C语言实现TCP通信客户端，发送保活报文和数据报文。
TCP-IP详解卷1
09-23
12.4.3 FDDI和令牌环网络中的多播 134 12.5 小结 134 第13章 IGMP：Internet组管理协议 136 13.1 引言 136 13.2 IGMP报文 136 13.3 IGMP协议 136 13.3.1 加入一个多播组 136 13.3.2 IGMP报告和查询 137 13.3.3 实现...
TCP-IP详解卷2
09-23
1.4 应用编程接口 3 1.5 程序示例 4 1.6 系统调用和库函数 6 1.7 网络实现概述 6 1.8 描述符 7 1.9 mbuf与输出处理 11 1.9.1 包含插口地址结构的mbuf 11 1.9.2 包含数据的mbuf 12 1.9.3 添加IP和UDP首部 13 1.9.4 IP...
【协议森林】Linux下socket编程KEEPALIVE使用与原理
平凡的世界
11-22 2977
1.简介 在实际项目开发中，TCP连接关闭主要有两种情况： 1、连接正常关闭，调用close() 、shutdown()连接优雅关闭，send与recv立马返回错误； 2、连接的对端异常关闭,比如拔掉网线网络断掉，突然断电。 面对上述问题，通常都要检测对端是否处于连接中，主要有两种方法： 1、编写心跳包程序，简单的说就是自己的程序加入一条线程,定时向对端发送数据包，查看是否有ACK，根据ACK的返回情况来管理连接。此方法比较通用，一般使用业务层心跳处理，灵活可控，但改变了现有的协议； 2、使用TCP的
setsockopt之 TCP_KEEPIDLE/TCP_KEEPINTVL/TCP_KEEPCNT
weixin_34010566的博客
06-29 2520
setsockopt之 TCP_KEEPIDLE/TCP_KEEPINTVL/TCP_KEEPCNT       /*检测网线非法断开*/    setsockopt(iSockFd, SOL_SOCKET, SO_KEEPALIVE, (void*)&amp;KeepAlive,sizeof(KeepAlive));    setsockopt(iSockFd, SOL_TCP, TCP_K...
Socket keepalive相关问题
yuxinying5160的博客
10-31 276
【问题描述】 CTRL-VM为TCP Server（192.168.0.1），BRAS-VM 97为TCP Client1（192.168.0.66），BRAS-VM 99为TCP Client 2（192.168.0.67）。 当BRAS-VM 97和BRAS-VM 99与CTRL-VM分别建立TCP连接后，分别将BRAS-VM 97和BRAS-VM 99关闭电源，从CTRL-VM查看BRAS-VM 97的TCP连接断开，BRAS-VM 99的TCP连接仍然存在，二者现象不一致。 【问题..
getsockopt的TCP层实现剖析
qiaotokong的专栏
05-11 2833
http://blog.csdn.net/zhangskd/article/details/8561950
TCP 保活机制(keepalive)
weixin_28673511的博客
05-01 2700
TCP keepalive保活机制，一篇文章搞懂。
Linux下getsockopt/setsockopt 函数说明
dianxinxiaozi2的专栏
12-18 938
Linux下getsockopt/setsockopt 函数说明 转载自https://www.cnblogs.com/dpf-learn/p/6124106.html getsockopt/setsockopt系统调用 功能描述：  获取或者设置与某个套接字关联的选 项。选项可能存在于多层协议中，它们总会出现在最上面的套接字层。当操作套接字选项时，选项位于的层和选项的名称必须给出。为了操作套...
socket保活方案 Tcp KeepAlive和应用层HeartBeat
单的博客
04-09 1751
两种方案： 1. TCP提供的keepalive2. 应用层heartbeat机制 keepalive 是系统内核就做好的东西，socket提供了设置启用的方法。原理是tcp连接闲置一段时间后，通过发送数据包（ack包）等待回复确认。几次过后，都没有回复的话，认为断开。 heartbeat 一个心跳机制。通常是客户端每隔一小段时间向服务器发送一个数据包，通知服务器自己仍然在线，并传输一些可能必...
TCP长连接的连接池、容量控制与心跳保活
互联网架构师笔记
04-19 1863
想要简单，不追求高性能，使用短连接合适，这样我们就不需要操心连接状态的管理；想要追求性能，使用长连接，我们就需要担心各种问题：比如端对端连接的维护，连接的保活。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值