tcp 端口复用与惊群效应（REUSEADDR、REUSEPORT）

已于 2022-02-16 22:55:22 修改
阅读量4.4k 收藏 8
点赞数
分类专栏： 通信协议 文章标签： 服务器 linux socket SO_REUSEADDR SO_REUSEPORT
于 2022-02-16 16:06:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanghuaichao/article/details/122962933
版权

我在之前的一篇文章中，介绍了我在之前的项目中遇到的端口复用，windows 的udp里端口复用导致了一个bug,具体的链接参考如下：

关于Socket中端口复用_zhc的博客-CSDN博客_socket端口复用

而我现在是想总结一下，linux下的情况，想从头再梳理下，REUSEADDR 和 REUSEPORT的作用。

1.SO_REUSEADDR 是为了解决time_wait问题而产生的

SO_REUSEADDR 它的作用是当服务器端主动断开链接的时候，处在timewait阶段大约60秒钟，服务器重新启动的话，会出现这个错误："Address already in use"

而如果服务器的套接字设置了这个选项，就可以再一次绑定这个 ip和端口。

而这个就衍生了一个问题。就是我可以在两个不同网卡的同一个端口上进行绑定tcp服务器，也要用到这个字段，这里一定要注意的是，一定是两个不同的真实ip，如果一个是通用的

INADDR_ANY（也就是我们常说的0.0.0.0），另外一个是10.2.4.567 也不行，一会报这个错误，还有一个要注意的是，报错不是在bind的时候报错，而是在监听的时候报错。

下面的代码就会报错，具体的代码粘贴如下：

//
// Created by hczhang on 2022/2/15.
//

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<signal.h>
#include<sys/wait.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include <errno.h>

#define BUF_SIZE 30
void read_childproc(int sig);

int main(int argc,char *argv[]){
    int serv_sock,clnt_sock,serv_sock1;
    struct sockaddr_in serv_adr,clnt_adr,serv_adr1;



    pid_t pid;
    struct sigaction act;
    socklen_t adr_sz;
    int str_len,state;
    char buf[BUF_SIZE];

    act.sa_handler = read_childproc;
    sigemptyset(&act.sa_mask);
    act.sa_flags=0;
    state = sigaction(SIGCHLD,&act,0);
    serv_sock = socket(AF_INET,SOCK_STREAM,0);
    serv_sock1 = socket(AF_INET,SOCK_STREAM,0);
    int option=1;
    socklen_t optlen = sizeof(option);
    printf("server bind start\n");
    setsockopt(serv_sock,SOL_SOCKET,SO_REUSEADDR,(void*)&option,optlen);
    setsockopt(serv_sock1,SOL_SOCKET,SO_REUSEADDR,(void*)&option,optlen);


    memset(&serv_adr,0,sizeof(serv_adr));
    serv_adr.sin_family=AF_INET;
    serv_adr.sin_addr.s_addr= htonl(atoi("0.0.0.0"));

    serv_adr.sin_port= htons(atoi("12345"));

    memset(&serv_adr1,0,sizeof(serv_adr1));
    serv_adr1.sin_family=AF_INET;
    serv_adr1.sin_addr.s_addr= htonl(atoi("10.2.6.185"));

    serv_adr1.sin_port= htons(atoi("12345"));


    if(bind(serv_sock,(struct sockaddr*)&serv_adr,sizeof(serv_adr))==-1){
        printf("1 bind error:%s\n", strerror(errno));
        exit(1);
    }

    if(bind(serv_sock1,(struct sockaddr*)&serv_adr1,sizeof(serv_adr1))==-1){
        printf("2 bind error:%s\n", strerror(errno));
        exit(1);
    }

    if(listen(serv_sock,5)==-1){
        printf("1 listen error:%s\n", strerror(errno));
        exit(1);
    }

    if(listen(serv_sock1,5)==-1){
        printf("2 listen error:%s\n", strerror(errno));
        exit(1);
    }

    while(1){
        adr_sz = sizeof(clnt_adr);
        clnt_sock = accept(serv_sock,(struct sockaddr*)&clnt_adr,&adr_sz);
        if(clnt_sock==-1){
            printf("accept error:%s\n",strerror(errno));
            continue;
        }

        else
            printf("new client connected...\n");
        pid = fork();
        if(pid ==-1){
            close(clnt_sock);
            continue;
        }
        // 子进程运行区域
        if(pid == 0){
            printf("child process enter!!!\n");
            close(serv_sock);//把复制过来的句柄关闭
            while((str_len= read(clnt_sock,buf,BUF_SIZE)!=0)){
                write(clnt_sock,buf,str_len);
            }
            close(clnt_sock);
            printf("client disconnected...\n");
            return 0;
        }else{
            //父进程执行区域
            close(clnt_sock);
        }

    }
    close(serv_sock);

    return 0;
}
void read_childproc(int sig){
    pid_t pid;
    int status;
    pid = waitpid(-1,&status,WNOHANG);
    printf("removed proc id:%d\n",pid);
}

这个程序启动后就会报错，如果把0.0.0.0改成一个真实的不重复的ip就不会报错了。

2.SO_REUSEPORT 是为了解决惊群问题而产生的

刚才说了SO_REUSEADDR的两个ip不能相同，但是SO_REUSEPORT为了解决惊群效应，能让其绑定相同的ip,和端口，具体的测试代码如下：

//
// Created by hczhang on 2022/2/15.
//

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<signal.h>
#include<sys/wait.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include <errno.h>

#define BUF_SIZE 30
void read_childproc(int sig);

int main(int argc,char *argv[]){
    int serv_sock,clnt_sock,serv_sock1;
    struct sockaddr_in serv_adr,clnt_adr,serv_adr1;



    pid_t pid;
    struct sigaction act;
    socklen_t adr_sz;
    int str_len,state;
    char buf[BUF_SIZE];

    act.sa_handler = read_childproc;
    sigemptyset(&act.sa_mask);
    act.sa_flags=0;
    state = sigaction(SIGCHLD,&act,0);
    serv_sock = socket(AF_INET,SOCK_STREAM,0);
    serv_sock1 = socket(AF_INET,SOCK_STREAM,0);
    int option=1;
    socklen_t optlen = sizeof(option);
    printf("server bind start\n");
    setsockopt(serv_sock,SOL_SOCKET,SO_REUSEPORT,(void*)&option,optlen);
    setsockopt(serv_sock1,SOL_SOCKET,SO_REUSEPORT,(void*)&option,optlen);


    memset(&serv_adr,0,sizeof(serv_adr));
    serv_adr.sin_family=AF_INET;
    serv_adr.sin_addr.s_addr= htonl(atoi("0.0.0.0"));

    serv_adr.sin_port= htons(atoi("12345"));

    memset(&serv_adr1,0,sizeof(serv_adr1));
    serv_adr1.sin_family=AF_INET;
    serv_adr1.sin_addr.s_addr= htonl(atoi("10.2.6.185"));

    serv_adr1.sin_port= htons(atoi("12345"));


    if(bind(serv_sock,(struct sockaddr*)&serv_adr,sizeof(serv_adr))==-1){
        printf("1 bind error:%s\n", strerror(errno));
        exit(1);
    }

    if(bind(serv_sock1,(struct sockaddr*)&serv_adr1,sizeof(serv_adr1))==-1){
        printf("2 bind error:%s\n", strerror(errno));
        exit(1);
    }

    if(listen(serv_sock,5)==-1){
        printf("1 listen error:%s\n", strerror(errno));
        exit(1);
    }

    if(listen(serv_sock1,5)==-1){
        printf("2 listen error:%s\n", strerror(errno));
        exit(1);
    }

    while(1){
        adr_sz = sizeof(clnt_adr);
        clnt_sock = accept(serv_sock,(struct sockaddr*)&clnt_adr,&adr_sz);
        if(clnt_sock==-1){
            printf("accept error:%s\n",strerror(errno));
            continue;
        }

        else
            printf("new client connected...\n");
        pid = fork();
        if(pid ==-1){
            close(clnt_sock);
            continue;
        }
        // 子进程运行区域
        if(pid == 0){
            printf("child process enter!!!\n");
            close(serv_sock);//把复制过来的句柄关闭
            while((str_len= read(clnt_sock,buf,BUF_SIZE)!=0)){
                write(clnt_sock,buf,str_len);
            }
            close(clnt_sock);
            printf("client disconnected...\n");
            return 0;
        }else{
            //父进程执行区域
            close(clnt_sock);
        }

    }
    close(serv_sock);

    return 0;
}
void read_childproc(int sig){
    pid_t pid;
    int status;
    pid = waitpid(-1,&status,WNOHANG);
    printf("removed proc id:%d\n",pid);
}

只是之前的 SO_REUSEADDR换成SO_REUSEPORT就可以了，不报错了程序启动后。

而惊群问题的解决方案有两个：

除了加锁的解决方法外，还有其他2个办法：
1. 利用reuseport机制（需要3.9以后版本），但这需要在每个子进程去创建监听端口（而不是继承父进程的），这样就可以保证每个子进程的套接字都是独立的，它们都有自己的accept队列，由内核来做负载均衡；
2. liunx 4.5内核在epoll已经新增了EPOLL_EXCLUSIVE选项，在多个进程同时监听同一个socket，只有一个被唤醒。

具体的原理我暂时不再这里记录，先把两种解决方案的代码实现下：

对于reuseport机制，具体多进程代码如下所示：

客户端代码统一都是一个（可以用一个网络助手来代替）：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<signal.h>
#include<sys/wait.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<errno.h>

#define BUF_SIZE 1024

int main(int argc,char *argv[]){
    int sock;
    char message[BUF_SIZE];
    int str_len,recv_len,recv_cnt;

    struct sockaddr_in serv_addr;

    sock = socket(AF_INET,SOCK_STREAM,0);

    if(sock ==-1){
        printf("socket error\n");
    }

    memset(&serv_addr,0,sizeof(serv_addr));

    serv_addr.sin_family=AF_INET;
    serv_addr.sin_addr.s_addr= htonl(atoi("0.0.0.0"));
    serv_addr.sin_port = htons(atoi("12345"));

    if(connect(sock,(struct sockaddr*)&serv_addr,sizeof(serv_addr))==-1){
        printf("connect error,%d\n",errno);
		exit(1);
    }else{
        printf("connected........\n");
    }

    while (1){
        fputs("Input message(Q/q to quit): ",stdout);
        fgets(message,BUF_SIZE,stdin);
        if(!strcmp(message,"q\n")||!strcmp(message,"Q\n"))
            break;
        str_len = write(sock,message, strlen(message));
		printf("send data to server %s size is:%d\n",message,str_len);
		// 在这里等到从server读取到等量的数据再显示
        recv_len=0;
        while(recv_len<str_len){
            recv_cnt = read(sock,&message[recv_len],BUF_SIZE-1);
            if(recv_cnt ==-1){
                printf("read error\n");
            }
            recv_len+=recv_cnt;
        }
        message[recv_len]=0;//字符串结尾放\0
        printf("Message from server:%s",message);
    }
    close(sock);
    return 0;
}

对应的服务器代码如下：

#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#define PROCESS_NUM 10
#define MAXEVENTS 64
// socket创建和绑定
int sock_creat_bind(char *port) {
  int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
  struct sockaddr_in serveraddr;
  serveraddr.sin_family = AF_INET;
  serveraddr.sin_port = htons(atoi(port));
  serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);

  // 设置reuseport
  int option = 1;
  socklen_t optlen = sizeof(option);
  setsockopt(sock_fd, SOL_SOCKET, SO_REUSEPORT, (void *)&option, optlen);
  printf("i have set reuse port\n");

  bind(sock_fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));

  printf("sock_fd is :%d\n", sock_fd);
  return sock_fd;
}
//利用fcntl设置文件或者函数调用的状态标志
int make_nonblocking(int fd) {
  int val = fcntl(fd, F_GETFL);
  val |= O_NONBLOCK;
  if (fcntl(fd, F_SETFL, val) < 0) {
    perror("fcntl set");
    return -1;
  }
  return 0;
  /*
   * int flag = fcntl(fd,F_GETFL,0);
  fcntl(fd,F_SETFL,flag|O_NONBLOCK);
   * */
}

int main(int argc, char *argv[]) {



  if (argc < 2) {
    printf("usage: [port] %s", argv[1]);
    exit(1);
  }


  int i;
  for (i = 0; i < PROCESS_NUM; ++i) {
    int pid = fork();
    if (pid == 0) {
    int epoll_fd;
        if ((epoll_fd = epoll_create(MAXEVENTS)) < 0) {
            perror("epoll_create");
            exit(1);
        }
        int sock_fd;

      if ((sock_fd = sock_creat_bind(argv[1])) < 0) {
        perror("socket and bind");
        exit(1);
      }
      if (make_nonblocking(sock_fd) < 0) {
        perror("make non blocking");
        exit(1);
      }
      if (listen(sock_fd, SOMAXCONN) < 0) {
        perror("listen");
        exit(1);
      }
      struct epoll_event event;
      event.data.fd = sock_fd;
      event.events = EPOLLIN;
      if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock_fd, &event) < 0) {
        perror("epoll_ctl");
        exit(1);
      }
      /*buffer where events are returned*/
        struct epoll_event *events;
      events = (struct epoll_event *)calloc(MAXEVENTS, sizeof(event));
      while (1) {
        int num, j;
        num = epoll_wait(epoll_fd, events, MAXEVENTS, -1);
        printf("process %d return from epoll_wait\n", getpid());
        sleep(2);
        for (i = 0; i < num; ++i) {
          if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) ||
              (!(events[i].events & EPOLLIN))) {
            fprintf(stderr, "epoll error\n");
            close(events[i].data.fd);
            continue;
          } else if (sock_fd == events[i].data.fd) {
            //收到关于监听套接字的通知，意味着一个或者多个传入连接
            struct sockaddr in_addr;
            socklen_t in_len = sizeof(in_addr);
            if (accept(sock_fd, &in_addr, &in_len) < 0) {
              printf("process %d accept failed %s\n", getpid(),
                     strerror(errno));
            } else {
              printf("process %d accept successful!\n", getpid());
            }
          }
        }
      }
    }
  }
  wait(0);

  return 0;
}

现在看reuseport解决了惊群问题，无论是水平触发和边沿触发

对于这个 EPOLLEXCLUSIVE选项，我进行了下测试代码如下：

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<sys/epoll.h>
#include<netdb.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys/wait.h>
#include<errno.h>
#define PROCESS_NUM 10
#define MAXEVENTS 64
//socket创建和绑定
int sock_creat_bind(char * port){
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in serveraddr;
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(port));
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);

    // 设置reuseport
 /*   int option=1;
    socklen_t optlen = sizeof(option);
    setsockopt(sock_fd,SOL_SOCKET,SO_REUSEPORT,(void*)&option,optlen);*/
    printf("i donot set reuse port\n");

    bind(sock_fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));


    return sock_fd;
}
//利用fcntl设置文件或者函数调用的状态标志
int make_nonblocking(int fd){
    int val = fcntl(fd, F_GETFL);
    val |= O_NONBLOCK;
    if(fcntl(fd, F_SETFL, val) < 0){
        perror("fcntl set");
        return -1;
    }
    return 0;
    /*
     * int flag = fcntl(fd,F_GETFL,0);
    fcntl(fd,F_SETFL,flag|O_NONBLOCK);
     * */
}

int main(int argc, char *argv[])
{
    int sock_fd, epoll_fd;
    struct epoll_event event;
    struct epoll_event *events;

    if(argc < 2){
        printf("usage: [port] %s", argv[1]);
        exit(1);
    }
    if((sock_fd = sock_creat_bind(argv[1])) < 0){
        perror("socket and bind");
        exit(1);
    }
    if(make_nonblocking(sock_fd) < 0){
        perror("make non blocking");
        exit(1);
    }
    if(listen(sock_fd, SOMAXCONN) < 0){
        perror("listen");
        exit(1);
    }
    if((epoll_fd = epoll_create(MAXEVENTS))< 0){
        perror("epoll_create");
        exit(1);
    }
    event.data.fd = sock_fd;
    event.events = EPOLLIN|EPOLLEXCLUSIVE;
    if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock_fd, &event) < 0){
        perror("epoll_ctl");
        exit(1);
    }
    /*buffer where events are returned*/
    events = (struct epoll_event*)calloc(MAXEVENTS, sizeof(event));
    int i;
    for(i = 0; i < PROCESS_NUM; ++i){
        int pid = fork();
        if(pid == 0){
            while(1){
                int num, j;
                num = epoll_wait(epoll_fd, events, MAXEVENTS, -1);
                printf("process %d return from epoll_wait\n", getpid());
                // sleep(2);
                for(i = 0; i < num; ++i){
                    if((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))){
                        fprintf(stderr, "epoll error\n");
                        close(events[i].data.fd);
                        continue;
                    }else if(sock_fd == events[i].data.fd){
                        //收到关于监听套接字的通知，意味着一个或者多个传入连接
                        struct sockaddr in_addr;
                        socklen_t in_len = sizeof(in_addr);
                        if(accept(sock_fd, &in_addr, &in_len) < 0){
                            printf("process %d accept failed!\n", getpid());
                        }else{
                            printf("process %d accept successful!\n", getpid());
                        }
                    }
                }
            }
        }
    }
    wait(0);
    free(events);
    close(sock_fd);
    return 0;
}

当收到客户端的发送数据请求时，当我们不设置边沿触发的情况，默认是水平触发，则输出结果如下：

hczhang@hczhang-OptiPlex-3050:~/testcommono/socket/tcp_server$ gcc thunder_epoll.cpp -o ghj
hczhang@hczhang-OptiPlex-3050:~/testcommono/socket/tcp_server$ ./ghj 12345
i donot set reuse port
process 16319 return from epoll_wait
process 16318 return from epoll_wait
process 16319 accept successful!
process 16318 accept failed!
 

我们看，并不是所有的进程都被唤醒了，而只是唤醒了两个。这个感觉是水平触发的影响。

具体可以参考下这篇博客的解释：

​​​​​​epoll的陷阱实践 | 演道网

主要的关键的摘录如下：

1.这个标识肯定是有作用的。因为源码是公开的，并且官方文档中也写明了。

epoll: add EPOLLEXCLUSIVE flag · torvalds/linux@df0108c · GitHub

2.导致所有线程都被唤醒的原因可能是因为LT模式。LT模式的特点是，如果epoll中监听的socket有事件，那么不管什么时候调用，epoll_wait都会返回。我们设置了EPOLLEXCLUSIVE标识，可以保证所有的epoll_wait同时调用的时候只有一个返回，但是这个线程返回之后，在调用accept把监听事件从epoll中取出来之前，别的线程的epoll_wait也在阻塞监听，就相当于这个时候又有epoll_wait调用，基于LT的特点，所以又返回了。

最后的结果就是，LT模式下的EPOLLEXCLUSIVE并不能解决监听套接字的惊群问题

我把上面的

event.events = EPOLLIN|EPOLLEXCLUSIVE;

替换为

event.events = EPOLLIN|EPOLLEXCLUSIVE|EPOLLET;

的话就只是唤起一个进程了。

修改后输出结果如下：

i donot set reuse port
process 7901 return from epoll_wait
process 7901 accept successful!

针对这个标志位的多线程模型代码如下，和多进程模型没有啥区别：

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<sys/epoll.h>
#include<netdb.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys/wait.h>
#include<errno.h>
#include<pthread.h>
#define PROCESS_NUM 10
#define MAXEVENTS 64
//socket创建和绑定
int sock_creat_bind(char * port){
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in serveraddr;
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(port));
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);

    // 设置reuseport
    /*   int option=1;
       socklen_t optlen = sizeof(option);
       setsockopt(sock_fd,SOL_SOCKET,SO_REUSEPORT,(void*)&option,optlen);*/
    printf("i donot set reuse port\n");

    bind(sock_fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));


    return sock_fd;
}
//利用fcntl设置文件或者函数调用的状态标志
int make_nonblocking(int fd){
    int val = fcntl(fd, F_GETFL);
    val |= O_NONBLOCK;
    if(fcntl(fd, F_SETFL, val) < 0){
        perror("fcntl set");
        return -1;
    }
    return 0;
    /*
     * int flag = fcntl(fd,F_GETFL,0);
    fcntl(fd,F_SETFL,flag|O_NONBLOCK);
     * */
}


int sock_fd, epoll_fd;
struct epoll_event event;
struct epoll_event *events;
// thread function
void * thread_func(void *args){
    printf("i am the new thread id:%ld\n",pthread_self());
    while(1){
        int num;
        num = epoll_wait(epoll_fd, events, MAXEVENTS, -1);
        printf("process %d return from epoll_wait\n", getpid());
        sleep(2);
        for(int i = 0; i < num; ++i){
            if((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))){
                fprintf(stderr, "epoll error\n");
                close(events[i].data.fd);
                continue;
            }else if(sock_fd == events[i].data.fd){
                //收到关于监听套接字的通知，意味着一个或者多个传入连接
                struct sockaddr in_addr;
                socklen_t in_len = sizeof(in_addr);
                if(accept(sock_fd, &in_addr, &in_len) < 0){
                    printf("process %d accept failed!\n", getpid());
                }else{
                    printf("process %d accept successful!\n", getpid());
                }
            }
        }
    }
}
int main(int argc, char *argv[])
{


    if(argc < 2){
        printf("usage: [port] %s", argv[1]);
        exit(1);
    }
    if((sock_fd = sock_creat_bind(argv[1])) < 0){
        perror("socket and bind");
        exit(1);
    }
    if(make_nonblocking(sock_fd) < 0){
        perror("make non blocking");
        exit(1);
    }
    if(listen(sock_fd, SOMAXCONN) < 0){
        perror("listen");
        exit(1);
    }
    if((epoll_fd = epoll_create(MAXEVENTS))< 0){
        perror("epoll_create");
        exit(1);
    }
    event.data.fd = sock_fd;
    event.events = EPOLLIN|EPOLLEXCLUSIVE|EPOLLET;
    if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock_fd, &event) < 0){
        perror("epoll_ctl");
        exit(1);
    }
    /*buffer where events are returned*/
    events = (struct epoll_event*)calloc(MAXEVENTS, sizeof(event));
    pthread_t threadid;
    for(int i = 0; i < PROCESS_NUM; ++i){
        pthread_create(&threadid,NULL,thread_func,NULL);
        }
    while(1);
    return 0;
}


 

zhanghuaichao
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
epoll 的惊群效应
Elena's Blog
05-31 89
在多线程或者多进程环境下，有些人为了提高程序的稳定性，往往会让多个线程或者多个进程同时在 epoll_wait 监听的 socket 描述符。当一个新的链接请求进来时，操作系统不知道选派那个线程或者进程处理此事件，则干脆将其中几个线程或者进程给唤醒，而实际上只有其中一个进程或者线程能够成功处理 accept 事件，其他线程都将失败，且 errno 错误码为 EAGAIN。这种现象称为惊群效应，结果是肯定的，惊群效应肯定会带来资源的消耗和性能的影响。
网络编程中的SO_REUSEADDR和SO_REUSEPORT参数详解
赶路人儿
06-19 4905
在BSD中，SO_REUSEADDR选项有两个用户：setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR,(const void *)&reuse , sizeof(int));目的：当服务端出现timewait状态的链接时，确保server能够重启成功。注意：SO_REUSEADDR只有针对time-wait链接(linux系统time-wait连接持续时间为1min)，确保server重启成功的这一个作用。举个time_wait的连接通过so_reuseaddr选项
TCP复用：原理、应用与优势
最新发布
超级英雄吉姆的博客
06-09 822
在计算机网络中，TCP（传输控制协议）复用是一种关键机制，它允许不同的应用进程在相同的传输层协议上共享资源，从而提高网络效率和资源利用率。本文将详细探讨TCP复用的原理、应用以及所带来的优势。
setsockopt中参数SO_REUSEADDR的四个作功用
Kingbaiyulong的专栏
05-19 1389
一：SO_REUSEADDR是让端口释放后立即就可以被再次使用，即使以前建立的绑定该端口的连接仍然存在。 我们知道，tcp连接中主动执行关闭的那一端将处于TIME_WAIT状态，该端留在这个状态的持续时间叫做最长分节生命期(maximum segment lifetime,MSL)的两倍，一般MSL=30秒，即要等待一分钟之后该端口才能被重新使用。 所有TCP服务器都应该指定本套接字选项，以允
SO_REUSEADDR 和 SO_REUSEPORT 的区别和用法实例详细探究讲解
Wanglei110311089的博客
03-17 719
SO_REUSEADDR主要用来解决TIME_WAIT，SO_REUSEPORT解决端口可以重复调用问题，两者没有交集和冲突可以根据实际情况进行自由选择。
socket编程 REUSEADDR/REUSESOCK 参数区别
juggte的博客
08-22 830
介绍一下系统调用 setsockopt 的REUSEADDR/REUSESOCK 参数区别。众所周知，TCP连接中主动断开连接方会进入一个TIME_WAIT 状态，并连接会等待两个MSL时间才真正断开，来防止最后一个发送的ACK丢失也能重发和让数据包在网络中消散。
SO_REUSEADDR和SO_REUSEPORT在不同OS上的表现
赶路人儿
06-19 1122
TCP套接字的SO_REUSEADDR和SO_REUSEPORT选项，以及他们在不同操作系统中的表现。
delphi 端口复用
11-25
在IT行业中，端口复用（Port Reuse）是一种网络通信技术，主要用于提高网络资源的利用率和优化网络性能。在Delphi这样的编程环境中，开发者可以利用端口复用来创建高效且可靠的网络应用程序，特别是在内网中建立与...
端口复用
04-05
端口复用是一种网络通信技术，它允许在同一台主机上，不同进程或应用程序在同一时间重复使用相同的TCP或UDP端口号进行通信，而不引起冲突。在传统的网络编程中，每个网络连接通常都会绑定到一个唯一的端口号，以确保...
Python-端口复用相关思路和工具
08-12
Python中实现端口复用主要依赖于socket模块，特别是其SO_REUSEADDR和SO_REUSEPORT选项。SO_REUSEADDR允许在socket关闭后立即重新绑定到同一个端口，解决了传统TCP的TIME_WAIT问题，提高了服务器重启的响应速度。SO_...
Linux网络编程：端口复用
03-04
总结来说，Linux网络编程中的端口复用是一项重要的优化技术，通过设置SO_REUSEADDR和SO_REUSEPORT选项，我们可以更高效地管理端口资源，提升服务的响应速度和并发处理能力。在编程实践中，要根据具体需求和系统环境...
Socket端口复用
01-08
Socket端口复用是一种在TCP/IP通信中允许同一个主机上的多个进程绑定到同一个网络端口号的技术。这在某些场景下非常有用，例如服务器重启时快速重新绑定服务或在一个进程中同时运行多个相同服务副本。在本篇文章中，...
TCP选项之SO_REUSEADDR
yhc166188的博客
08-01 628
1、一般来说，一个端口释放后会等待两分钟之后才能再被使用，SO_REUSEADDR是让端口释放后立即就可以被再次使用。     SO_REUSEADDR用于对TCP套接字处于TIME_WAIT状态下的socket，才可以重复绑定使用。server程序总是应该在调用bind()之前设置SO_REUSEADDR套接字选项。TCP，先调用close()的一方会进入TIME_WAIT状态 2、SO_R...
TCP/IP总结
玖玖玖
03-12 239
网络编程基础知识
SO_REUSEADDR的作用
热门推荐
caomiao2006的专栏
04-23 1万+
原贴地址：http://topic.csdn.net/u/20090103/16/a0414edb-b289-4c72-84da-39e155e8f4be.html 如下演示程序，程序目的是： 先准备好一个ServerSocket，监听端口8880， 然后建一个ClientSocket（受限于业务需要，必须在ServerSocket准备好后再建Client），也必须绑定同一端口888
【博客318】网络编程：REUSEPORT的使用
qq_43684922的博客
06-22 550
内容： 记录reuseport的使用 使用实例： #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <stdio.h> #include <errno.h> #include <arpa/inet.h> #include <stdlib.h> int main() { int sockfd = socket(A
教你使用 SO_REUSEPORT 套接字选项提升服务性能
youzhangjing_的博客
11-22 853
Linux 网络栈中有一个相对较新的特性——SO_REUSEPORT 套接字选项，可以使用它来提升你的服务性能。图 1: 上面的服务是使用并行监听器来避免请求连接瓶颈，而下面的服务只使用一个监听器来接收连接概要HAProxy 和 NGINX 是少数几个使用 Linux 网络栈中 TCP 的 SO_REUSEPORT 套接字选项[1]的应用程序。这个选项最初是在 4.4 BSD 中引入的，帮助在现在大型多核系统中实现高性能服务。
SO_REUSEADDR 套接字选项应用实例
null
07-08 3184
网络上关于SO_REUSEADDR套接字选项用来解决地址重用问题的资料不少，但只停留在文字表达上，并没有实例，很容易误导初学者，并产生疑惑，此处不再赘述。下面通过一个简短的例子来展示如何在项目中合理的使用该选项，以及需要注意的问题。 关于TCP断开连接四次握手，如图所示 应用场景： 之前项目中遇到一个问题，聊天服务器的开启，关闭和重启，例如将服务器
tcp_tw_recycle和tcp_tw_reuse
secretx的专栏
04-07 6507
tcp_tw_recycle和tcp_tw_reuse tcp TIME_WAIT 进入主题前必须做铺垫啊,讲讲TIME_WAIT.因为TCP连接是双向的，所以在关闭连接的时候，两个方向各自都需要关闭。先发FIN包的一方执行的是主动关闭；后发FIN包的一方执行的是被动关闭。主动关闭的一方会进入TIME_WAIT状态，并且在此状态停留两倍的MSL(最大报文存活时间,一般Linux内核设置30秒)
解释一下tcp通信中端口复用
03-14
TCP通信中，端口复用是指在同一台计算机上，多个进程可以使用同一个端口号进行通信。这是通过在TCP/IP协议栈中使用SO_REUSEADDR选项来实现的。当一个进程使用完一个端口后，该端口并不会立即释放，而是在一定时间内处于TIME_WAIT状态，此时其他进程可以使用该端口。这样可以提高端口的利用率，减少端口资源的浪费。同时，端口复用还可以实现负载均衡和高可用性等功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值