深入研究socket编程（3）——使用select函数编写客户端和服务器

http://blog.csdn.net/chenxun_2010/article/details/50488394

首先看原先《UNIX网络编程——并发服务器（TCP）》的代码，服务器代码serv.c：

[cpp] view plaincopy
  1. #include<stdio.h>  
  2. #include<sys/types.h>  
  3. #include<sys/socket.h>  
  4. #include<unistd.h>  
  5. #include<stdlib.h>  
  6. #include<errno.h>  
  7. #include<arpa/inet.h>  
  8. #include<netinet/in.h>  
  9. #include<string.h>  
  10. #include<signal.h>  
  11.   
  12. #define ERR_EXIT(m) \  
  13.     do { \  
  14.         perror(m); \  
  15.         exit(EXIT_FAILURE); \  
  16.     } while (0)  
  17.   
  18. void do_service(int);  
  19.   
  20. int main(void)  
  21. {  
  22.     signal(SIGCHLD, SIG_IGN);  
  23.     int listenfd; //被动套接字(文件描述符），即只可以accept, 监听套接字  
  24.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
  25.         //  listenfd = socket(AF_INET, SOCK_STREAM, 0)  
  26.         ERR_EXIT("socket error");  
  27.   
  28.     struct sockaddr_in servaddr;  
  29.     memset(&servaddr, 0, sizeof(servaddr));  
  30.     servaddr.sin_family = AF_INET;  
  31.     servaddr.sin_port = htons(5188);  
  32.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
  33.     /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */  
  34.     /* inet_aton("127.0.0.1", &servaddr.sin_addr); */  
  35.   
  36.     int on = 1;  
  37.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)  
  38.         ERR_EXIT("setsockopt error");  
  39.   
  40.     if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)  
  41.         ERR_EXIT("bind error");  
  42.   
  43.     if (listen(listenfd, SOMAXCONN) < 0) //listen应在socket和bind之后，而在accept之前  
  44.         ERR_EXIT("listen error");  
  45.   
  46.     struct sockaddr_in peeraddr; //传出参数  
  47.     socklen_t peerlen = sizeof(peeraddr); //传入传出参数，必须有初始值  
  48.     int conn; // 已连接套接字(变为主动套接字，即可以主动connect)  
  49.   
  50.     pid_t pid;  
  51.   
  52.     while (1)  
  53.     {  
  54.         if ((conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen)) < 0) //3次握手完成的序列  
  55.         {  
  56.             if( errno == EINTR )            ///必须处理被中断的系统调用  
  57.                continue;  
  58.             else  
  59.                ERR_EXIT("accept error");  
  60.         }        
  61.         printf("recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),  
  62.                ntohs(peeraddr.sin_port));  
  63.   
  64.         pid = fork();  
  65.         if (pid == -1)  
  66.             ERR_EXIT("fork error");  
  67.         if (pid == 0)  
  68.         {  
  69.             // 子进程  
  70.             close(listenfd);  
  71.             do_service(conn);  
  72.             exit(EXIT_SUCCESS);  
  73.         }  
  74.         else  
  75.             close(conn); //父进程  
  76.     }  
  77.   
  78.     return 0;  
  79. }  
  80.   
  81. void do_service(int conn)  
  82. {  
  83.     char recvbuf[1024];  
  84.     while (1)  
  85.     {  
  86.         memset(recvbuf, 0, sizeof(recvbuf));  
  87.         int ret = read(conn, recvbuf, sizeof(recvbuf));  
  88.         if (ret == 0)   //客户端关闭了  
  89.         {  
  90.             printf("client close\n");  
  91.             break;  
  92.         }  
  93.         else if (ret == -1)  
  94.             ERR_EXIT("read error");  
  95.         fputs(recvbuf, stdout);  
  96.         write(conn, recvbuf, ret);  
  97.     }  
  98. }  

客户端代码cli.c：

[cpp] view plaincopy
  1. #include<stdio.h>  
  2. #include<sys/types.h>  
  3. #include<sys/socket.h>  
  4. #include<unistd.h>  
  5. #include<stdlib.h>  
  6. #include<errno.h>  
  7. #include<arpa/inet.h>  
  8. #include<netinet/in.h>  
  9. #include<string.h>  
  10.   
  11.   
  12. #define ERR_EXIT(m) \  
  13.     do { \  
  14.         perror(m); \  
  15.         exit(EXIT_FAILURE); \  
  16.     } while (0)  
  17.   
  18.   
  19.   
  20.   
  21. int main(void)  
  22. {  
  23.     int sock;  
  24.     if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
  25.         //  listenfd = socket(AF_INET, SOCK_STREAM, 0)  
  26.         ERR_EXIT("socket error");  
  27.   
  28.   
  29.     struct sockaddr_in servaddr;  
  30.     memset(&servaddr, 0, sizeof(servaddr));  
  31.     servaddr.sin_family = AF_INET;  
  32.     servaddr.sin_port = htons(5188);  
  33.     servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
  34.     /* inet_aton("127.0.0.1", &servaddr.sin_addr); */  
  35.   
  36.     if (connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)  
  37.         ERR_EXIT("connect error");  
  38.     struct sockaddr_in localaddr;  
  39.     char cli_ip[20];  
  40.     socklen_t local_len = sizeof(localaddr);  
  41.     memset(&localaddr, 0, sizeof(localaddr));  
  42.     if( getsockname(sock,(struct sockaddr *)&localaddr,&local_len) != 0 )  
  43.         ERR_EXIT("getsockname error");  
  44.     inet_ntop(AF_INET, &localaddr.sin_addr, cli_ip, sizeof(cli_ip));  
  45.     printf("host %s:%d\n", cli_ip, ntohs(localaddr.sin_port));   
  46.   
  47.     char sendbuf[1024] = {0};  
  48.     char recvbuf[1024] = {0};  
  49.     while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)  
  50.     {  
  51.   
  52.         write(sock, sendbuf, strlen(sendbuf));  
  53.         read(sock, recvbuf, sizeof(recvbuf));  
  54.   
  55.   
  56.         fputs(recvbuf, stdout);  
  57.   
  58.         memset(sendbuf, 0, sizeof(sendbuf));  
  59.         memset(recvbuf, 0, sizeof(recvbuf));  
  60.     }  
  61.   
  62.   
  63.     close(sock);  
  64.   
  65.   
  66.     return 0;  
  67. }  


 先运行服务器端，再运行客户端：

[cpp] view plaincopy
  1. huangcheng@ubuntu:~$ ./serv  
  2. huangcheng@ubuntu:~$ ./cli  


先查看一下网络状态：

[cpp] view plaincopy
  1. huangcheng@ubuntu:~$ netstat -anp | grep 5188  
  2. （并非所有进程都能被检测到，所有非本用户的进程信息将不会显示，如果想看到所有信息，则必须切换到 root 用户）  
  3. tcp        0      0 0.0.0.0:5188            0.0.0.0:*               LISTEN      2750/serv  
  4. tcp        0      0 127.0.0.1:49484         127.0.0.1:5188          ESTABLISHED 2751/cli  
  5. tcp        0      0 127.0.0.1:5188          127.0.0.1:49484         ESTABLISHED 2752/serv  

可以看出建立了连接，服务器端有两个进程，一个父进程处于监听状态，另一子进程正在对客户端进行服务。


服务器端的子进程的pid为2752，并kill掉它：

[cpp] view plaincopy
  1. huangcheng@ubuntu:~$ kill -9 2752  

再查看一下网络状态：
[cpp] view plaincopy
  1. huangcheng@ubuntu:~$ netstat -anp | grep 5188  
  2. （并非所有进程都能被检测到，所有非本用户的进程信息将不会显示，如果想看到所有信息，则必须切换到 root 用户）  
  3. tcp        0      0 0.0.0.0:5188            0.0.0.0:*               LISTEN      2750/serv  
  4. tcp        1      0 127.0.0.1:49484         127.0.0.1:5188          CLOSE_WAIT  2751/cli  
  5. tcp        0      0 127.0.0.1:5188          127.0.0.1:49484         FIN_WAIT2   -  

     来分析一下，我们将server子进程  kill掉，则其终止时，socket描述符会自动关闭并发FIN段给client，client收到FIN后处于CLOSE_WAIT状态，但是client并没有终止，也没有关闭socket描述符，因此不会发FIN给 server子进程，因此server 子进程的TCP连接处于FIN_WAIT2状态。

为什么会出现这种情况呢，来看client的部分程序：

[cpp] view plaincopy
  1. char sendbuf[1024] = {0};  
  2. char recvbuf[1024] = {0};  
  3. while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)  
  4. {  
  5.   
  6.     write(sock, sendbuf, strlen(sendbuf));  
  7.     read(sock, recvbuf, sizeof(recvbuf));  
  8.   
  9.   
  10.     fputs(recvbuf, stdout);  
  11.   
  12.     memset(sendbuf, 0, sizeof(sendbuf));  
  13.     memset(recvbuf, 0, sizeof(recvbuf));  
  14. }  
     客户端程序阻塞在了fgets 那里，即从标准输入读取数据，所以不能执行到下面的read，也即不能返回0，不会退出循环，不会调用close关闭sock，所以出现上述的情况，即状态停滞，不能向前推进。
     出现上述问题的根本原因在于客户端程序不能并发处理从标准输入读取数据和从套接字读取数据两个事件，我们可以使用前面讲过的select函数来完善客户端程序。


[cpp] view plaincopy
  1. int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);  

参数1：读写异常集合中的文件描述符的最大值加1；

参数2：读集合，关心可读事件；

套接口缓冲区有数据可读
连接的读一半关闭，即接收到FIN段，读操作将返回0
如果是监听套接口，已完成连接队列不为空时。
套接口上发生了一个错误待处理，错误可以通过getsockopt指定SO_ERROR选项来获取。

参数3：写集合，关心可写事件；

套接口发送缓冲区有空间容纳数据。

连接的写一半关闭。即收到RST段之后，再次调用write操作。

套接口上发生了一个错误待处理，错误可以通过getsockopt指定SO_ERROR选项来获取。

参数4：异常集合，关心异常事件；

套接口存在带外数据（TCP头部 URG标志，16位紧急指针字段）

参数5：超时时间结构体


对于参数2，3，4来说，如果不关心对应事件则设置为NULL即可。注意5个参数都是输入输出参数，即select返回时可能对其进行了修改，比如集合被修改以便标记哪些套接口发生了事件，时间结构体的传出参数是剩余的时间，如果设置为NULL表示永不超时。用select管理多个I/O，select阻塞等待，一旦其中的一个或多个I/O检测到我们所感兴趣的事件，select函数返回，返回值为检测到的事件个数，并且返回哪些I/O发送了事件，遍历这些事件，进而处理事件。注意当select阻塞返回后，此时调用read/write 是不会阻塞的，因为正是有可读可写事件发生才导致select 返回，也可以认为是select 提前阻塞了。

下面是4个可以对集合进行操作的宏：

[cpp] view plaincopy
  1. void FD_CLR(int fd, fd_set *set); // 清除出集合  
  2. int  FD_ISSET(int fd, fd_set *set); // 判断是否在集合中  
  3. void FD_SET(int fd, fd_set *set); // 添加进集合中  
  4. void FD_ZERO(fd_set *set); // 将集合清零  

下面是通过select函数改进的客户端的代码cli.c：

[cpp] view plaincopy
  1. #include<stdio.h>  
  2. #include<sys/types.h>  
  3. #include<sys/socket.h>  
  4. #include<unistd.h>  
  5. #include<stdlib.h>  
  6. #include<errno.h>  
  7. #include<arpa/inet.h>  
  8. #include<netinet/in.h>  
  9. #include<string.h>  
  10.   
  11.   
  12. #define ERR_EXIT(m) \  
  13.     do { \  
  14.         perror(m); \  
  15.         exit(EXIT_FAILURE); \  
  16.     } while (0)  
  17.   
  18.   
  19.   
  20.   
  21. int main(void)  
  22. {  
  23.     int sock;  
  24.     if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
  25.         //  listenfd = socket(AF_INET, SOCK_STREAM, 0)  
  26.         ERR_EXIT("socket error");  
  27.   
  28.   
  29.     struct sockaddr_in servaddr;  
  30.     memset(&servaddr, 0, sizeof(servaddr));  
  31.     servaddr.sin_family = AF_INET;  
  32.     servaddr.sin_port = htons(5188);  
  33.     servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
  34.     /* inet_aton("127.0.0.1", &servaddr.sin_addr); */  
  35.   
  36.     if (connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)  
  37.         ERR_EXIT("connect error");  
  38.     struct sockaddr_in localaddr;  
  39.     char cli_ip[20];  
  40.     socklen_t local_len = sizeof(localaddr);  
  41.     memset(&localaddr, 0, sizeof(localaddr));  
  42.     if( getsockname(sock,(struct sockaddr *)&localaddr,&local_len) != 0 )  
  43.         ERR_EXIT("getsockname error");  
  44.     inet_ntop(AF_INET, &localaddr.sin_addr, cli_ip, sizeof(cli_ip));  
  45.     printf("host %s:%d\n", cli_ip, ntohs(localaddr.sin_port));   
  46.   
  47.     fd_set rset;  
  48.     FD_ZERO(&rset);  
  49.     int nready;  
  50.     int maxfd;  
  51.     int fd_stdin = fileno(stdin); //  
  52.     if (fd_stdin > sock)  
  53.         maxfd = fd_stdin;  
  54.     else  
  55.         maxfd = sock;  
  56.     char sendbuf[1024] = {0};  
  57.     char recvbuf[1024] = {0};  
  58.       
  59.     while (1)  
  60.     {  
  61.   
  62.         FD_SET(fd_stdin, &rset);  
  63.         FD_SET(sock, &rset);  
  64.         nready = select(maxfd + 1, &rset, NULL, NULL, NULL); //select返回表示检测到可读事件  
  65.         if (nready == -1)  
  66.             ERR_EXIT("select error");  
  67.   
  68.         if (nready == 0)  
  69.             continue;  
  70.   
  71.         if (FD_ISSET(sock, &rset))  
  72.         {  
  73.   
  74.             int ret = read(sock, recvbuf, sizeof(recvbuf));   
  75.             if (ret == -1)  
  76.                 ERR_EXIT("read error");  
  77.             else if (ret  == 0)   //服务器关闭  
  78.             {  
  79.                 printf("server close\n");  
  80.                 break;  
  81.             }  
  82.   
  83.             fputs(recvbuf, stdout);  
  84.             memset(recvbuf, 0, sizeof(recvbuf));  
  85.         }  
  86.   
  87.         if (FD_ISSET(fd_stdin, &rset))  
  88.         {  
  89.   
  90.             if (fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)  
  91.                 break;  
  92.   
  93.             write(sock, sendbuf, strlen(sendbuf));  
  94.             memset(sendbuf, 0, sizeof(sendbuf));  
  95.         }  
  96.     }  
  97.   
  98.     close(sock);  
  99.     return 0;  
  100. }  

     即将两个事件都添加进可读事件集合，在while循环中，如果select返回说明有事件发生，依次判断是哪些事件发生，如果是标准输入有数据可读，则读取后再次回到循环开头select阻塞等待事件发生，如果是套接口有数据可读，且返回为0则说明对方已经关闭连接，退出循环并调用close关闭sock。

重复前面的操作：

（1）先运行服务器，再运行客户端

[cpp] view plaincopy
  1. huangcheng@ubuntu:~$ ./serv  
  2. huangcheng@ubuntu:~$ ./cli  
（2）查看网络状态：

[cpp] view plaincopy
  1. huangcheng@ubuntu:~$ netstat -anp | grep 5188  
  2. （并非所有进程都能被检测到，所有非本用户的进程信息将不会显示，如果想看到所有信息，则必须切换到 root 用户）  
  3. tcp        0      0 0.0.0.0:5188            0.0.0.0:*               LISTEN      2960/serv  
  4. tcp        0      0 127.0.0.1:49485         127.0.0.1:5188          ESTABLISHED 2963/cli  
  5. tcp        0      0 127.0.0.1:5188          127.0.0.1:49485         ESTABLISHED 2964/serv  
（3）kill掉服务器的子进程，再查看网络状态：

[cpp] view plaincopy
  1. huangcheng@ubuntu:~$ kill -9 2964  
  2. huangcheng@ubuntu:~$ netstat -anp | grep 5188  
  3. （并非所有进程都能被检测到，所有非本用户的进程信息将不会显示，如果想看到所有信息，则必须切换到 root 用户）  
  4. tcp        0      0 0.0.0.0:5188            0.0.0.0:*               LISTEN      2960/serv  
  5. tcp        0      0 127.0.0.1:5188          127.0.0.1:49485         TIME_WAIT   -  

     即 client 关闭socket描述符，server 子进程的TCP连接收到client发的FIN段后处于TIME_WAIT状态，此时会再发生一个ACK段给client，client接收到之后就处于CLOSED状态，这个状态存在时间很短，所以看不到客户端的输出条目，TCP协议规定，主动关闭连接的一方要处于TIME_WAIT状态，等待两个MSL（maximumsegment lifetime）的时间后才能回到CLOSED状态，需要有MSL 时间的主要原因是在这段时间内如果最后一个ack段没有发送给对方，则可以重新发送。

     过一小会再次查看网络状态：

[cpp] view plaincopy
  1. huangcheng@ubuntu:~$ netstat -anp | grep 5188  
  2. （并非所有进程都能被检测到，所有非本用户的进程信息将不会显示，如果想看到所有信息，则必须切换到 root 用户）  
  3. tcp        0      0 0.0.0.0:5188            0.0.0.0:*               LISTEN      2960/serv  
     可以发现只剩下服务器端父进程的监听状态了，由TIME_WAIT状态转入CLOSED状态，也很快会消失。


-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


     前面我们实现的能够并发服务的服务器端程序是使用fork出多个子进程来实现的，现在学习了select函数，可以用它来改进服务器端程序，实现单进程并发服务。先看如下程序，再来解释：

[cpp] view plaincopy
  1. #include<stdio.h>  
  2. #include<sys/types.h>  
  3. #include<sys/socket.h>  
  4. #include<unistd.h>  
  5. #include<stdlib.h>  
  6. #include<errno.h>  
  7. #include<arpa/inet.h>  
  8. #include<netinet/in.h>  
  9. #include<string.h>  
  10. #include<signal.h>  
  11. #include<sys/wait.h>  
  12.   
  13. #define ERR_EXIT(m) \  
  14.     do { \  
  15.         perror(m); \  
  16.         exit(EXIT_FAILURE); \  
  17.     } while (0)  
  18.   
  19.   
  20. int main(void)  
  21. {  
  22.       
  23.     signal(SIGPIPE, SIG_IGN);  
  24.     int listenfd; //被动套接字(文件描述符），即只可以accept, 监听套接字  
  25.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
  26. //  listenfd = socket(AF_INET, SOCK_STREAM, 0)    
  27.         ERR_EXIT("socket error");  
  28.   
  29.     struct sockaddr_in servaddr;  
  30.     memset(&servaddr, 0, sizeof(servaddr));  
  31.     servaddr.sin_family = AF_INET;  
  32.     servaddr.sin_port = htons(5188);  
  33.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   
  34.     /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */  
  35.     /* inet_aton("127.0.0.1", &servaddr.sin_addr); */  
  36.       
  37.     int on = 1;  
  38.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)  
  39.         ERR_EXIT("setsockopt error");  
  40.   
  41.     if (bind(listenfd, (struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)  
  42.         ERR_EXIT("bind error");  
  43.   
  44.     if (listen(listenfd, SOMAXCONN) < 0) //listen应在socket和bind之后，而在accept之前  
  45.         ERR_EXIT("listen error");  
  46.       
  47.     struct sockaddr_in peeraddr; //传出参数  
  48.     socklen_t peerlen = sizeof(peeraddr); //传入传出参数，必须有初始值  
  49.       
  50.     int conn; // 已连接套接字(变为主动套接字，即可以主动connect)  
  51.     int i;  
  52.     int client[FD_SETSIZE];  
  53.     int maxi = 0; // client数组中最大不空闲位置的下标  
  54.     for (i = 0; i < FD_SETSIZE; i++)  
  55.         client[i] = -1;  
  56.   
  57.     int nready;  
  58.     int maxfd = listenfd;  
  59.     fd_set rset;  
  60.     fd_set allset;  
  61.     FD_ZERO(&rset);  
  62.     FD_ZERO(&allset);  
  63.     FD_SET(listenfd, &allset);  
  64.   
  65.     while (1) {  
  66.         rset = allset;  
  67.         nready = select(maxfd + 1, &rset, NULL, NULL, NULL);  
  68.         if (nready == -1) {  
  69.             if (errno == EINTR)  
  70.                 continue;  
  71.             ERR_EXIT("select error");  
  72.         }  
  73.   
  74.         if (nready == 0)  
  75.             continue;  
  76.   
  77.         if (FD_ISSET(listenfd, &rset)) {  
  78.           
  79.             conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);  //accept不再阻塞  
  80.             if (conn == -1)  
  81.                 ERR_EXIT("accept error");  
  82.               
  83.             for (i = 0; i < FD_SETSIZE; i++) {  
  84.                 if (client[i] < 0) {  
  85.                     client[i] = conn;  
  86.                     if (i > maxi)  
  87.                         maxi = i;  
  88.                     break;  
  89.                 }   
  90.             }  
  91.               
  92.             if (i == FD_SETSIZE) {  
  93.                 fprintf(stderr, "too many clients\n");  
  94.                 exit(EXIT_FAILURE);  
  95.             }  
  96.   
  97.             printf("recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),  
  98.                 ntohs(peeraddr.sin_port));  
  99.   
  100.             FD_SET(conn, &allset);  
  101.             if (conn > maxfd)  
  102.                 maxfd = conn;  
  103.   
  104.             if (--nready <= 0)  
  105.                 continue;  
  106.         }  
  107.   
  108.         for (i = 0; i <= maxi; i++) {  
  109.             conn = client[i];  
  110.             if (conn == -1)  
  111.                 continue;  
  112.   
  113.             if (FD_ISSET(conn, &rset)) {  
  114.                   
  115.                 char recvbuf[1024] = {0};  
  116.                 int ret = read(conn, recvbuf, 1024);  
  117.                 if (ret == -1)  
  118.                     ERR_EXIT("readline error");  
  119.                 else if (ret  == 0) { //客户端关闭   
  120.                     printf("client close \n");  
  121.                     FD_CLR(conn, &allset);  
  122.                     client[i] = -1;  
  123.                     close(conn);  
  124.                 }  
  125.           
  126.                 fputs(recvbuf, stdout);  
  127.                 write(conn, recvbuf, strlen(recvbuf));  
  128.                   
  129.                 if (--nready <= 0)  
  130.                     break;   
  131.             }  
  132.         }  
  133.   
  134.   
  135.     }  
  136.           
  137.     return 0;  
  138. }  
  139.   
  140. /* select所能承受的最大并发数受 
  141.  * 1.一个进程所能打开的最大文件描述符数，可以通过ulimit -n来调整 
  142.  *   但一个系统所能打开的最大数也是有限的，跟内存有关，可以通过cat /proc/sys/fs/file-max 查看 
  143.  * 2.FD_SETSIZE(fd_set)的限制，这个需要重新编译内核                                                                           
  144.  */  


     程序第一次进入while 循环，只把监听套接字加入关心的事件，select返回说明监听套接字有可读事件，即已完成连接队列不为空，这时调用accept不会阻塞，返回一个已连接套接字，将这个套接字加入allset，因为第一次运行则nready = 1，直接continue跳回到while 循环开头，再次调用select，这次会关心监听套接字和一个已连接套接字的可读事件，如果继续有客户端连接上来则继续将其加入allset，这次nready = 2，继续执行下面的for 循环，然后对客户端进行服务。服务完毕再次回到while 开头调用select 阻塞时，就关心一个监听套接字和2个已连接套接字的可读事件了，一直循环下去。

     程序大概逻辑就这样，一些细节就大家自己想想了，比如client数组是用来保存已连接套接字的，为了避免每次都得遍历到FD_SETSIZE-1，保存一个最大不空闲下标maxi，每次遍历到maxi就可以了。每次得到一个conn，要判断一下conn与maxfd的大小。

当得知某个客户端关闭，则需要将conn在allset中清除掉。之所以要有allset 和 rset 两个变量是因为rset是传入传出参数，在select返回时rset可能被改变，故需要每次在回到while 循环开头时需要将allset 重新赋予rset 。



本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/383845.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Ubuntu安装搭建Clion环境

Ubuntu安装搭建Clion环境

呜呜呜&#xff0c;太辛苦了&#xff0c;我终于安装好这个了。 大概过程就是先在官网下载安装包&#xff0c;然后解压以后用终端移动到对应文件夹下运行clin.sh 运行完以后会有一些窗口&#xff0c;第一个选择don’t~~&#xff0c;然后点击ok 接受&#xff08;你可以不接受…
阅读更多...
UNIX网络编程——select函数的并发限制和 poll 函数应用举例

UNIX网络编程——select函数的并发限制和 poll 函数应用举例

http://blog.csdn.net/chenxun_2010/article/details/50489577 一、用select实现的并发服务器&#xff0c;能达到的并发数&#xff0c;受两方面限制 1、一个进程能打开的最大文件描述符限制。这可以通过调整内核参数。可以通过ulimit -n来调整或者使用setrlimit函数设置&#x…
阅读更多...
【Java学习笔记二】继承和多态

【Java学习笔记二】继承和多态

与C不同的是&#xff0c;在Java中&#xff0c;一个类只能直接继承另一个类&#xff0c;而不允许继承多个类&#xff0c;这个新类称为继承类、派生类或者子类&#xff0c;而被继承的类称为基类或者父类。 继承类能够继承基类的群不属性和行为。 面向对象程序设计的三大特点为&…
阅读更多...
Linux系统编程——线程池

Linux系统编程——线程池

http://blog.csdn.net/tennysonsky/article/details/46490099# 线程池基本原理 在传统服务器结构中&#xff0c;常是有一个总的监听线程监听有没有新的用户连接服务器&#xff0c;每当有一个新的用户进入&#xff0c;服务器就开启一个新的线程用户处理这 个用户的数据包。这个线…
阅读更多...
简单Linux C线程池

简单Linux C线程池

http://www.cnblogs.com/venow/archive/2012/11/22/2779667.html 大多数的网络服务器&#xff0c;包括Web服务器都具有一个特点&#xff0c;就是单位时间内必须处理数目巨大的连接请求&#xff0c;但是处理时间却是比较短的。在传统的多线程服务器模型中是这样实现的&#xff1…
阅读更多...
IO多路复用之poll总结

IO多路复用之poll总结

http://www.cnblogs.com/Anker/p/3261006.html 1、基本知识 poll的机制与select类似&#xff0c;与select在本质上没有多大差别&#xff0c;管理多个描述符也是进行轮询&#xff0c;根据描述符的状态进行处理&#xff0c;但是poll没有最大文件描述符数量的限制。poll和select同…
阅读更多...
【C++学习笔记二】C++继承

【C++学习笔记二】C++继承

继承 继承允许我们一句另一个类来定义一个类&#xff0c;这使得继承和维护一个程序变得更加容易&#xff0c;也达到了重用代码功能和提高执行效率的效果。 一般格式为&#xff1a; class 派生类名 :访问修饰符 基类名{};其中访问修饰符是public protected private中的一个&a…
阅读更多...
处理大并发之二 对epoll的理解，epoll客户端服务端代码

处理大并发之二 对epoll的理解，epoll客户端服务端代码

http://blog.csdn.net/wzjking0929/article/details/51838370 序言&#xff1a; 该博客是一系列的博客&#xff0c;首先从最基础的epoll说起&#xff0c;然后研究libevent源码及使用方法&#xff0c;最后研究nginx和node.js&#xff0c;关于select,poll这里不做说明&#xff0c…
阅读更多...
C++基类指针指向派生类（指针）

C++基类指针指向派生类（指针）

我们常用基类指针指向派生类对象来实现多态性。 私有继承不允许基类指针指向派生类 基类指针只能访问到基类中含有的公有成员。 当用基类指针指向派生类对象在动态分配堆上内存的时候&#xff0c;析构函数必须是虚函数! 成员如果是数据成员的话访问的是基类的版本&#xff…
阅读更多...
一个简单的linux线程池

一个简单的linux线程池

http://blog.csdn.net/wzjking0929/article/details/20312675 线程池&#xff1a;简单地说&#xff0c;线程池 就是预先创建好一批线程&#xff0c;方便、快速地处理收到的业务。比起传统的到来一个任务&#xff0c;即时创建一个线程来处理&#xff0c;节省了线程的创建和回收的…
阅读更多...
C++制表符

C++制表符

制表符的转义字符为\t&#xff0c;一般情况下长度为8个空格&#xff0c;这里的8个指的是从上一个字符串的开头开始算&#xff0c;往后数8个&#xff0c;不够的话就补空格。 如果前面的字符串的长度大于等于8个&#xff0c;例如前面字符串的长度为x,那么就会补(8-x%8)个空格 例…
阅读更多...
C++派生类含有成员对象构造函数析构函数顺序

C++派生类含有成员对象构造函数析构函数顺序

参考博客&#xff1a;传送门1 当类中含有对象成员时&#xff1a; 类的构造函数要包含对成员对象的初始化&#xff0c;如果构造函数的成员初始化列表没有包含对成员对象的初始化&#xff0c;系统会自动调用成员对象的无参构造函数。顺序上&#xff1a;先调用成员对象的构造函数…
阅读更多...
链表逆序的原理及实例

链表逆序的原理及实例

http://blog.csdn.net/wangqing_12345/article/details/51757294 尾插法建立链表&#xff0c;带头结点设链表节点为typedef struct node {int data;struct node *next;}node_t, *pnode_t;要求将一带链表头List head的单向链表逆序。 分析&#xff1a; 1). 若链表为空或只有一个…
阅读更多...
C++关于虚基类、构造函数、析构函数、成员对象的两个程序浅析

C++关于虚基类、构造函数、析构函数、成员对象的两个程序浅析

预备博客&#xff1a; C虚继承中构造函数和析构函数顺序问题以及原理 C派生类含有成员对象构造函数析构函数顺序 C虚基类成员可见性 程序一如下&#xff1a; #include<iostream> using namespace std; class A { public:A(int a) :x(a) { cout << "A const…
阅读更多...
C++小型公司管理系统

C++小型公司管理系统

项目要求&#xff1a; 编写一个程序实现小型公司的人员信息管理系统。该公司雇员&#xff08;employee&#xff09;包括经理&#xff08;manager&#xff09;&#xff0c;技术人员&#xff08;technician&#xff09;、销售员&#xff08;salesman&#xff09;和销售部经理&…
阅读更多...
Linux网络编程“惊群”问题总结

Linux网络编程“惊群”问题总结

http://www.cnblogs.com/Anker/p/7071849.html 1、前言 我从事Linux系统下网络开发将近4年了&#xff0c;经常还是遇到一些问题&#xff0c;只是知其然而不知其所以然&#xff0c;有时候和其他人交流&#xff0c;搞得非常尴尬。如今计算机都是多核了&#xff0c;网络编程框架也…
阅读更多...
yfan.qiu linux硬链接与软链接

yfan.qiu linux硬链接与软链接

http://www.cnblogs.com/yfanqiu/archive/2012/06/11/2545556.html Linux 系统中有软链接和硬链接两种特殊的“文件”。 软链接可以看作是Windows中的快捷方式&#xff0c;可以让你快速链接到目标档案或目录。 硬链接则透过文件系统的inode来产生新档名&#xff0c;而不是产生…
阅读更多...
Linux C++线程池实例

Linux C++线程池实例

http://www.cnblogs.com/danxi/p/6636095.html 想做一个多线程服务器测试程序&#xff0c;因此参考了github的一些实例&#xff0c;然后自己动手写了类似的代码来加深理解。 目前了解的线程池实现有2种思路&#xff1a; 第一种&#xff1a; 主进程创建一定数量的线程&#xff0…
阅读更多...
Java编写简单的自定义异常类

Java编写简单的自定义异常类

除了系统中自己带的异常&#xff0c;我们也可以自己写一些简单的异常类来帮助我们处理问题。 所有的异常命名都是以Exception结尾&#xff0c;并且都是Exception的子类。 假设我们要编写一个人类的类&#xff0c;为了判断年龄的输入是否合法&#xff0c;我们编写了一个名为Il…
阅读更多...
【Java学习笔记九】多线程

【Java学习笔记九】多线程

程序&#xff1a;计算机指令的集合&#xff0c;它以文件的形式存储在磁盘上&#xff0c;是应用程序执行的蓝本。 进程&#xff1a;是一个程序在其自身的地址空间中的一次执行活动。进程是资源申请、调度和独立运行的单位&#xff0c;因此&#xff0c;它使用系统中的运行资源。而…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023