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

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

一、用select实现的并发服务器，能达到的并发数，受两方面限制


       1、一个进程能打开的最大文件描述符限制。这可以通过调整内核参数。可以通过ulimit -n来调整或者使用setrlimit函数设置， 但一个系统所能打开的最大数也是有限的，跟内存大小有关，可以通过cat /proc/sys/fs/file-max 查看

       2、select中的fd_set集合容量的限制（FD_SETSIZE，一般为1024） ，这需要重新编译内核。


可以写个测试程序，只建立连接，看看最多能够建立多少个连接，客户端程序如下：

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


huangcheng@ubuntu:~$ ./serv  
count = 1  
recv connect ip=127.0.0.1 port=48370  
count = 2  
recv connect ip=127.0.0.1 port=48371  
count = 3  
recv connect ip=127.0.0.1 port=48372  
count = 4  
recv connect ip=127.0.0.1 port=48373  
....................................  
recv connect ip=127.0.0.1 port=49389  
count = 1020  
recv connect ip=127.0.0.1 port=49390  



accept error: Too many open files  
[cpp] view plaincopyprint?
huangcheng@ubuntu:~$ ./cli  
ip=127.0.0.1 port=46327  
count = 1  
ip=127.0.0.1 port=46328  
count = 2  
ip=127.0.0.1 port=46329  
count = 3  
ip=127.0.0.1 port=46330  
count = 4  
ip=127.0.0.1 port=46331  
count = 5  
ip=127.0.0.1 port=46332  
count = 6  
ip=127.0.0.1 port=46333  
.......................  
ip=127.0.0.1 port=47345  
count = 1020  
ip=127.0.0.1 port=47346  
count = 1021  
socket: Too many open files  


输出太多条目，上面只截取最后几条，从中可以看出对于客户端，最多只能开启1021个连接套接字，因为总共是1024个，还得除去0、1、2。而服务器端只能accept 返回1020个已连接套接字，因为除了0、1、2之外还有一个监听套接字，客户端某一个套接字（不一定是最后一个）虽然已经建立了连接，在已完成连接队列中，但accept 返回时达到最大描述符限制，返回错误，打印提示信息。


       也许有人会注意到上面有一行 sleep(4)；当客户端调用socket准备创建第1022个套接字时，如上所示也会提示错误，此时socket函数返回-1出错，如果没有睡眠4s后再退出进程会有什么问题呢？如果直接退出进程，会将客户端所打开的所有套接字关闭掉，即向服务器端发送了很多FIN段，而此时也许服务器端还一直在accept ，即还在从已连接队列中返回已连接套接字，此时服务器端除了关心监听套接字的可读事件，也开始关心前面已建立连接的套接字的可读事件，read 返回0，所以会有很多 client close 字段 参杂在条目的输出中，还有个问题就是，因为read 返回0，服务器端会将自身的已连接套接字关闭掉，那么也许刚才说的客户端某一个连接会被accept 返回，即测试不出服务器端真正的并发容量。

  1. huangcheng@ubuntu:~$ ./serv  
  2. count = 1  
  3. recv connect ip=127.0.0.1 port=50413  
  4. count = 2  
  5. ....................................  
  6. client close  
  7. client close  
  8. client close  
  9. client close  
  10. ...................................  
  11. recv connect ip=127.0.0.1 port=51433  
  12. client close  
  13. count = 1021  
  14. recv connect ip=127.0.0.1 port=51364  
  15. client close  
  16. client close  
      可以看到输出参杂着client close，且这次的count 达到了1021，原因就是服务器端前面已经有些套接字关闭了，所以accept 创建套接字不会出错，服务器进程也不会因为出错而退出，可以看到最后接收到的一个连接端口是51364，即不一定是客户端的最后一个连接。

二、poll 函数应用举例


[cpp] view plaincopy
  1. #include <poll.h>  
  2. int poll(struct pollfd *fds, nfds_t nfds, int timeout);  
参数1：结构体数组指针

[cpp] view plaincopy
  1. struct pollfd {  
  2.     int   fd;         /* file descriptor */  
  3.     short events;     /* requested events */  
  4.     short revents;    /* returned events */  
  5. };  

结构体中的fd 即套接字描述符，events 即感兴趣的事件，如下图所示，revents 即返回的事件。


参数2：结构体数组的成员个数，即文件描述符个数。

参数3：即超时时间，若为-1，表示永不超时。


       poll 跟 select 还是很相似的，比较重要的区别在于poll 所能并发的个数跟FD_SETSIZE无关，只跟一个进程所能打开的文件描述符个数有关，可以在select 程序的基础上修改成poll 程序，在运行服务器端程序之前，使用ulimit -n 2048 将限制改成2048个，注意在运行客户端进程的终端也需更改，因为客户端也会有所限制，这只是临时性的更改，因为子进程会继承这个环境参数，而我们是在bash命令行启动程序的，故在进程运行期间，文件描述符的限制为2048个。

使用poll 函数的服务器端程序如下：

[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. #include<poll.h>  
  13.   
  14. #define ERR_EXIT(m) \  
  15.     do { \  
  16.         perror(m); \  
  17.         exit(EXIT_FAILURE); \  
  18.     } while (0)  
  19.   
  20.   
  21. int main(void)  
  22. {  
  23.     int count = 0;  
  24.     signal(SIGPIPE, SIG_IGN);  
  25.     int listenfd; //被动套接字(文件描述符），即只可以accept, 监听套接字  
  26.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
  27.         //  listenfd = socket(AF_INET, SOCK_STREAM, 0)  
  28.         ERR_EXIT("socket error");  
  29.   
  30.     struct sockaddr_in servaddr;  
  31.     memset(&servaddr, 0, sizeof(servaddr));  
  32.     servaddr.sin_family = AF_INET;  
  33.     servaddr.sin_port = htons(5188);  
  34.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
  35.     /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */  
  36.     /* inet_aton("127.0.0.1", &servaddr.sin_addr); */  
  37.   
  38.     int on = 1;  
  39.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)  
  40.         ERR_EXIT("setsockopt error");  
  41.   
  42.     if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)  
  43.         ERR_EXIT("bind error");  
  44.   
  45.     if (listen(listenfd, SOMAXCONN) < 0) //listen应在socket和bind之后，而在accept之前  
  46.         ERR_EXIT("listen error");  
  47.   
  48.     struct sockaddr_in peeraddr; //传出参数  
  49.     socklen_t peerlen = sizeof(peeraddr); //传入传出参数，必须有初始值  
  50.   
  51.     int conn; // 已连接套接字(变为主动套接字，即可以主动connect)  
  52.     int i;  
  53.   
  54.     struct pollfd client[2048];  
  55.     int maxi = 0; //client[i]最大不空闲位置的下标  
  56.   
  57.     for (i = 0; i < 2048; i++)  
  58.         client[i].fd = -1;  
  59.   
  60.     int nready;  
  61.     client[0].fd = listenfd;  
  62.     client[0].events = POLLIN;  
  63.   
  64.     while (1)  
  65.     {  
  66.         /* poll检测[0, maxi + 1) */  
  67.         nready = poll(client, maxi + 1, -1);  
  68.         if (nready == -1)  
  69.         {  
  70.             if (errno == EINTR)  
  71.                 continue;  
  72.             ERR_EXIT("poll error");  
  73.         }  
  74.   
  75.         if (nready == 0)  
  76.             continue;  
  77.   
  78.         if (client[0].revents & POLLIN)  
  79.         {  
  80.   
  81.             conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen); //accept不再阻塞  
  82.             if (conn == -1)  
  83.                 ERR_EXIT("accept error");  
  84.   
  85.             for (i = 1; i < 2048; i++)  
  86.             {  
  87.                 if (client[i].fd < 0)  
  88.                 {  
  89.                     client[i].fd = conn;  
  90.                     if (i > maxi)  
  91.                         maxi = i;  
  92.                     break;  
  93.                 }  
  94.             }  
  95.   
  96.             if (i == 2048)  
  97.             {  
  98.                 fprintf(stderr, "too many clients\n");  
  99.                 exit(EXIT_FAILURE);  
  100.             }  
  101.   
  102.             printf("count = %d\n", ++count);  
  103.             printf("recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),  
  104.                    ntohs(peeraddr.sin_port));  
  105.   
  106.             client[i].events = POLLIN;  
  107.   
  108.             if (--nready <= 0)  
  109.                 continue;  
  110.         }  
  111.   
  112.         for (i = 1; i <= maxi; i++)  
  113.         {  
  114.             conn = client[i].fd;  
  115.             if (conn == -1)  
  116.                 continue;  
  117.             if (client[i].revents & POLLIN)  
  118.             {  
  119.   
  120.                 char recvbuf[1024] = {0};  
  121.                 int ret = read(conn, recvbuf, 1024);  
  122.                 if (ret == -1)  
  123.                     ERR_EXIT("readline error");  
  124.                 else if (ret  == 0)   //客户端关闭  
  125.                 {  
  126.                     printf("client  close \n");  
  127.                     client[i].fd = -1;  
  128.                     close(conn);  
  129.                 }  
  130.   
  131.                 fputs(recvbuf, stdout);  
  132.                 write(conn, recvbuf, strlen(recvbuf));  
  133.   
  134.                 if (--nready <= 0)  
  135.                     break;  
  136.             }  
  137.         }  
  138.   
  139.   
  140.     }  
  141.   
  142.     return 0;  
  143. }  
  144.   
  145. /* poll 只受一个进程所能打开的最大文件描述符限制，这个可以使用ulimit -n调整 */  

参照前面对 select 函数 的解释不难理解上面的程序，就不再赘述了。来看一下输出：


[cpp] view plaincopy
  1. root@ubuntu:/home/huangcheng# ulimit -n 2048  
  2. root@ubuntu:/home/huangcheng# su - huangcheng  
  3. huangcheng@ubuntu:~$ ulimit -n  
  4. 2048  
  5. huangcheng@ubuntu:~$ ./serv  
  6. ...........................  
  7. count = 2042  
  8. recv connect ip=127.0.0.1 port=54499  
  9. count = 2043  
  10. recv connect ip=127.0.0.1 port=54500  
  11. count = 2044  
  12. recv connect ip=127.0.0.1 port=54501  
  13. accept error: Too many open files  
[cpp] view plaincopy
  1. root@ubuntu:/home/huangcheng# ulimit -n 2048  
  2. root@ubuntu:/home/huangcheng# su - huangcheng  
  3. huangcheng@ubuntu:~$ ulimit -n  
  4. 2048  
  5. huangcheng@ubuntu:~$./cli  
  6. ..........................  
  7. ip=127.0.0.1 port=54499  
  8. count = 2043  
  9. ip=127.0.0.1 port=54500  
  10. count = 2044  
  11. ip=127.0.0.1 port=54501  
  12. count = 2045  
  13. socket: Too many open files  
       可以看到现在最大的连接数已经是2045个了，虽然服务器端有某个连接没有accept 返回。即poll 比 select 能够承受更多的并发连接，只受一个进程所能打开的最大文件描述符个数限制。可以通过ulimit -n  修改，但一个系统所能打开的文件描述符个数也是有限的，这跟系统的内存大小有关系，所以说也不是可以无限地并 发，可以查看一下本机的容量：

[cpp] view plaincopy
  1. huangcheng@ubuntu:~$ cat /proc/sys/fs/file-max  
  2. 101598  
本机是虚拟机，内存2G，能够打开的文件描述符个数大约在10w个左右。


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

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

相关文章

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

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

与C不同的是&#xff0c;在Java中&#xff0c;一个类只能直接继承另一个类&#xff0c;而不允许继承多个类&#xff0c;这个新类称为继承类、派生类或者子类&#xff0c;而被继承的类称为基类或者父类。 继承类能够继承基类的群不属性和行为。 面向对象程序设计的三大特点为&…
阅读更多...
使用poll实现的io多路复用服务端和客户端

使用poll实现的io多路复用服务端和客户端

http://blog.csdn.net/robertkun/article/details/52269313 参考&#xff1a;http://www.cnblogs.com/Anker/p/3261006.html 使用poll实现的io多路复用服务端和客户端。 客户端通过子进程创建多个客户端连接。 客户端每隔1秒向服务端发送一个时间戳&#xff0c; 服务端接收到时…
阅读更多...
【Java学习笔记三】抽象类与接口

【Java学习笔记三】抽象类与接口

对象的类型转换分为自动转换和强制转换两种 派生类向基类转换是自动转换&#xff0c;因为派生类中包含基类基类向派生类的转换是强制转换 强制类型转换是通过在转换对象前面使用圆括号运算符来实现&#xff0c;圆括号内为要转换的目标类型&#xff0c;格式为&#xff1a; (&…
阅读更多...
Epoll 的tcp通信代码（服务器+客户端）

Epoll 的tcp通信代码（服务器+客户端）

http://blog.csdn.net/libinbin_1014/article/details/50096187 Epoll 的tcp通信代码&#xff08;服务器客户端&#xff09; /* gcc -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS64 -I${ORACLE_HOME}/rdbms/public -I${ORACLE_HOME}/rdbms/demo -L${ORACLE_HOME}/lib -lclntsh …
阅读更多...
【Java学习笔记四】Java中的包

【Java学习笔记四】Java中的包

包的声明和引入&#xff1a;在Java语言系统中&#xff0c;Java编译器为每一个类生成一个字节码文件&#xff08;.class&#xff09;&#xff0c;为了对类文件进行分层和按用途分类管理&#xff0c;同时也为了解决相同类名的文件冲突的问题&#xff0c;Java提供了包机制来管理类…
阅读更多...
Linux系统编程——线程池

Linux系统编程——线程池

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

【Java学习笔记五】Java异常处理

异常通常分为三类&#xff1a; 程序可控制的异常&#xff1a;一般是可预见的错误&#xff0c;不是致命的。例如&#xff1a;除数为0&#xff0c;数组下标越界。程序不可控制的的异常&#xff1a;这种异常往往是致命的&#xff0c;但是系统可以预见的。例如&#xff1a;系统栈溢…
阅读更多...
【C++学习笔记一】C++类和对象详解

【C++学习笔记一】C++类和对象详解

类定义是以关键字class开头&#xff0c;后面跟类的名称。主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。 类的对象的公共数据成员可以使用直接成员访问运算符.来访问。需要注意的是&#xff0c;私有的成员和受保护的成员不能直接使用成员访问运算符来访…
阅读更多...
C语言实现的简单的线程池

C语言实现的简单的线程池

http://www.linuxidc.com/Linux/2013-01/77619.htm 有时我们会需要大量线程来处理一些相互独立的任务&#xff0c;为了避免频繁的申请释放线程所带来的开销&#xff0c;我们可以使用线程池。下面是一个C语言实现的简单的线程池。 头文件&#xff1a; 1: #ifndef THREAD_POOL_H_…
阅读更多...
C++获取当前时间

C++获取当前时间

可以使用windowsAPI直接获取。 例如&#xff1a; #include<windows.h> #include<cstdio>using namespace std;int main() {SYSTEMTIME now;GetLocalTime(&now);printf("现在是%02d时%02d分%02d秒\n",now.wHour,now.wMinute,now.wSecond);printf(&…
阅读更多...
成员函数后面加上const的作用

成员函数后面加上const的作用

const表示成员函数不会修改类中的数据成员。 规则&#xff1a; 在类中被const 声明的函数只能访问const 函数&#xff0c;而非const 函数可以访问任意成员函数。在成员函数中不管数据是否具有const 属性&#xff0c;编译器检查的的是是否有修改&#xff08;赋值&#xff0c;自…
阅读更多...
简单Linux C线程池

简单Linux C线程池

http://www.cnblogs.com/venow/archive/2012/11/22/2779667.html 大多数的网络服务器&#xff0c;包括Web服务器都具有一个特点&#xff0c;就是单位时间内必须处理数目巨大的连接请求&#xff0c;但是处理时间却是比较短的。在传统的多线程服务器模型中是这样实现的&#xff1…
阅读更多...
C++创建对象：栈和堆的区别

C++创建对象：栈和堆的区别

首先我们应该了解栈和堆的差别&#xff1a; 详细信息&#xff1a;传送门 栈相当于函数自带的存储空间&#xff0c;在windows下一般为2M,在Linux下一般为8M&#xff0c;存取速度稍微快一点。堆是系统的空间&#xff0c;相对较大&#xff0c;一般为2G&#xff0c;效率稍微慢一点…
阅读更多...
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…
阅读更多...
C++虚继承中构造函数和析构函数顺序问题以及原理

C++虚继承中构造函数和析构函数顺序问题以及原理

多重继承的问题&#xff1a;多个类B,C,…继承同一个类A导致如果X继承了B,C,…那么在X中将还有多个A中成员的拷贝&#xff0c;如果想要访问A中的成员如果不加名字空间将会导致二义性&#xff0c;这种拷贝大多是没有实际意义的&#xff0c;为了避免这种空间浪费&#xff0c;C有虚…
阅读更多...
一个简单的linux线程池

一个简单的linux线程池

http://blog.csdn.net/wzjking0929/article/details/20312675 线程池&#xff1a;简单地说&#xff0c;线程池 就是预先创建好一批线程&#xff0c;方便、快速地处理收到的业务。比起传统的到来一个任务&#xff0c;即时创建一个线程来处理&#xff0c;节省了线程的创建和回收的…
阅读更多...
【C++学习笔记三】C++多态、抽象（接口）

【C++学习笔记三】C++多态、抽象（接口）

当类之间存在多种层次结构&#xff0c;并且类之间通过继承关联时就会用到多态。 虚函数在子类中的覆盖版本和该函数在基类中的原始版本必须有相同的函数签名、函数名、形参名、常属性。如果返回值为非类类型&#xff0c;则必须相同&#xff0c;如果是类类型A的指针或者引用&am…
阅读更多...
最新文章

Copyright @ 2022~2023