并发服务器

服务器，配景服务软件，后端开发，为软件客户端提供支持，数据支持，存储支持，数据中转
高并发要求，随着用户数目的增长，服务器的计划结构扩展，为更多用户提供服务器。
Web服务器(网页网站的后端都是web服务器)，软件服务器(手机软件或者pc软件)。
开源服务器软件Apache,Nginx,用户配置即可使用，提供web服务器。
关于网页网站二点技术标准：共用协议（http https），超文本标记语言html，端标语共享使用http=80 https=443。
软件服务器，因不同软件不同功能，服务器的结构也不同，所以很难开源，因为并不适用其他软件。
后端开发的操作体系(服务器操作体系)，Linux,Unix,window server,大多数都是控制台体系。
服务器集群：1.处理服务器（128核），2.图形处理器（GPU）渲染或图形盘算，3.数据库服务器 多版本数据库兼容。4.文件存储体系。
搭建集群的本钱比力高。
服务器的焦点使命，网络穿透。
服务器作为信息中转站，帮助所有用户转接数据，变更网络情况，用户重新毗连服务器，重新提交信息，服务器实时更新客户端的网络信息。
代理服务器

哀求与响应（Request/Response）一次交互。
代理服务器可以作为过滤层，摆设防火墙，防DOS攻击等等，隐藏主服务器。
横向扩展服务器硬件，分布式结构。分布式管理程序：资源共享，资源利用最大化，让每台处理机统一分配管理与调度，成为一个个体。
负载平衡概念：将大量的业务哀求匀称分发给n个处理单元。制止某些处理单元过载，制止某些处理单元长期闲置。
轮询分发（逐个分发）
根据处理单元的负载情况，决定如何分配。
心跳机制 Keep_alive

心跳测试，在一个时间段内，要通过心跳测试测试对端存活是否有效，有效保持毗连，无效断开毗连。
操作体系自带心跳机制(setsocketopt)，这个心跳机制默认下要很久才能检测出对端是否断开。
如果一个毗连，一段时间没有交互，会被冷处理，通过间隔收发心跳包，让毗连保持活性，制止被冷处理。
单历程服务器

毗连部门，业务处理部门，协议解析部门。毗连部门和业务处理部门都是阻塞的，哀求时无法毗连，等待毗连时无法读取哀求。
单历程服务端，满意根本tcp毗连，完成简单的数据交互，对于体系时间的哀求和响应。
htons();将 16 位的短整数（如端标语）从主机字节顺序转换为网络字节顺序。
htonl();将 32 位整数从主机字节顺序转换为网络字节顺序。
INADDR_ANY，服务器将绑定到所有可用的网络接口上。这意味着服务器将接受任何网卡或接口上的毗连，而不限定于一个特定的 IP 地址。
bind()用于将一个套接字绑定到一个特定的地址和端口。绑定操作告诉操作体系，当有数据到达这个特定的 IP 地址和端口时，应该将数据交给这个套接字处理。
单历程阻塞

服务端：

1. #include<stdio.h>
2. #include<sys/fcntl.h>
3. #include<sys/types.h>
4. #include<sys/stat.h>
5. #include<time.h>
6. #include<string.h>
7. #include<arpa/inet.h>
8. #include<sys/socket.h>
9. #include<unistd.h>
10. #include<stdlib.h>
12. int init_net()
13. {
14.     int sock;
15.     struct sockaddr_in sockaddr;
16.     bzero(&sockaddr,sizeof(sockaddr));
17.     sockaddr.sin_family=AF_INET;
18.     sockaddr.sin_port=htons(1234);
19.     sockaddr.sin_addr.s_addr=htonl(INADDR_ANY);
20.     if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
21.         printf("socket error\n");
22.     else printf("socket ok\n");
23.     if((bind(sock,(struct sockaddr*)&sockaddr,sizeof(sockaddr)))==-1)
24.     {
25.         perror("bind error\n");
26.     }
27.     else printf("bind ok\n");
28.     listen(sock,128);
29.     return sock;
30. }
32. void mess_response(int so,struct sockaddr_in addr)
33. {
34.     char s[1024];
35.     char c[16];
36.     bzero(c,16);
37.     bzero(s,1024);
38.     inet_ntop(AF_INET,&addr.sin_addr,c,16);
39.     sprintf(s,"hi %s\n",c);
40.     int t=send(so,s,strlen(s),MSG_NOSIGNAL);
41.     if(t<0)
42.     {
43.     perror("err");
44.     }
45.     return;
46. }
48. int recv_request(int sock)
49. {
50.     char s[1024];
51.     char tim[1024];
52.     bzero(s,sizeof(s));
53.     bzero(tim,sizeof(tim));
54.     int len;
55.     time_t tp;
56.     while((len=recv(sock,s,sizeof(s),0))>0)
57.     {
58.     s[strlen(s)-1]='\0';
59.     if(strncmp(s,"time",strlen(s))==0)
60.     {
61.         tp=time(NULL);
62.         ctime_r(&tp,tim);
63.         send(sock,tim,strlen(tim),MSG_NOSIGNAL);
64.     }
65.     else{
66.         send(sock,"try again",9,MSG_NOSIGNAL);
67.     }
68.     bzero(s,sizeof(s));
69.     bzero(tim,sizeof(tim));
70.     }
71.     if(len==0)
72.     {
73.         printf("client sock %d its exiting...\n",sock);
74.         close(sock);
75. }
76. }
77. int main()
78. {
79.     int sock,csock;
80.     struct sockaddr_in sock_client;
81.     bzero(&sock_client,sizeof(sock_client));
82.     sock=init_net();
83.     printf("init ok\n");
84.     socklen_t socklen;
85.     while(1)
86.     {
87.     socklen=sizeof(sock_client);
88.    if(( csock=(accept(sock,(struct sockaddr*)&sock_client,&socklen)))==-1)
89.     perror("err\n");
90.    else{
91.        printf("accept success\n");
92.    }
93.     mess_response(csock,sock_client);
94.     recv_request(csock);
95.     }
96.     close(csock);
97.     close(sock);
98.     return 0;
99. }

复制代码

客户端：

1. #include<stdio.h>
2. #include<unistd.h>
3. #include<stdlib.h>
4. #include<arpa/inet.h>
5. #include<signal.h>
6. #include<sys/socket.h>
7. #include<sys/fcntl.h>
8. #include<string.h>
9. int main()
10. {
11.     int sock;
12.     struct sockaddr_in serveraddr;
13.     serveraddr.sin_family=AF_INET;
14.     serveraddr.sin_port=htons(1234);
15.     inet_pton(AF_INET,"127.0.0.1",&serveraddr.sin_addr.s_addr);
16.     if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
17.     {
18.         printf("socket error\n");
19.     }
20.     else printf("socket success\n");
21.     if((connect(sock,(struct sockaddr*)&serveraddr,sizeof(serveraddr)))==-1)
22.     {
23.         printf("connect error\n");
24.     }
25.     else{
26.         printf("connect success\n");
27.     }
28.     char buff[1024];
29.     bzero(buff,1024);
30.     int r=recv(sock,buff,sizeof(buff),0);
31.     printf("%d\n",r);
32.     //if((recv(sock,buff,sizeof(buff),0))==-1)
33.     //{
34.       //  perror("recv error\n");
35.     //}
36.     //else printf("recv ok\n");
37.     printf("%s\n",buff);
38. bzero(buff,1024);
39.     while((fgets(buff,sizeof(buff),stdin))!=NULL)
40.     {
41.         send(sock,buff,strlen(buff),MSG_NOSIGNAL);
42.         bzero(buff,1024);
43.         recv(sock,buff,sizeof(buff),0);
44.         printf("%s\n",buff);
45.     }
46.     close(sock);
47.     return 0;
48. }

复制代码

单历程非阻塞轮询模子

服务端：

1. #include<stdio.h>
2. #include<sys/fcntl.h>
3. #include<sys/types.h>
4. #include<sys/stat.h>
5. #include<time.h>
6. #include<string.h>
7. #include<arpa/inet.h>
8. #include<sys/socket.h>
9. #include<unistd.h>
10. #include<stdlib.h>
11. #include<fcntl.h>
12. #include<sys/types.h>
13. #include<sys/stat.h>
14. #include<errno.h>
15. int clientsock[10000];
16. int init_net();
17. void mess_response(int,struct sockaddr_in);
18. int recv_request(int);
19. int start_server();
22. #include<server.h>
23. void mess_response(int so,struct sockaddr_in addr)
24. {
25.         char s[1024];
26.         char c[16];
27.         bzero(c,16);
28.         bzero(s,1024);
29.         inet_ntop(AF_INET,&addr.sin_addr,c,16);
30.          sprintf(s,"hi %s\n",c);
31.           int t=send(so,s,strlen(s),MSG_NOSIGNAL);
32.           if(t<0)perror("err");
33.           return;
34. }
37. #include<server.h>
38. int recv_request(int sock)
39. {
40.         char s[1024];
41.         char tim[1024];
42.         bzero(s,sizeof(s));
43.         bzero(tim,sizeof(tim));
44.         int len;
45.         time_t tp;
46.         int i=0;
47.         for(i;i<10000;i++)
48.         {
49.         if(clientsock[i]!=-1)
50.         {
51.         if((len=recv(clientsock[i],s,sizeof(s),MSG_DONTWAIT))>0)
52.         {
53.         s[strlen(s)-1]='\0';
54.         if(strncmp(s,"time",strlen(s))==0)
55.         {
56.                 tp=time(NULL);
57.                 ctime_r(&tp,tim);
58.                 send(clientsock[i],tim,strlen(tim),MSG_NOSIGNAL);
59.         }
60.         else{
61.                 send(clientsock[i],"try again",9,MSG_NOSIGNAL);
62.         }
63.         bzero(s,sizeof(s));
64.         bzero(tim,sizeof(tim));
65.         }
66.         if(len==0)
67.         {
68.                 printf("client sock %d its exiting...\n",sock);
69.                 close(clientsock[i]);
70.                 clientsock[i]=-1;
71.         }
72.         }
73.         }
74. }
77. #include<server.h>
78. int server_start()
79. {
80.         int sock,csock;
81.         struct sockaddr_in sock_client;
82.         int i;
83.         for(i=0;i<10000;i++)
84.         clientsock[i]=-1;
85.         bzero(&sock_client,sizeof(sock_client));
86.         sock=init_net();
87.         printf("init ok\n");
88.         int flag;
89.         fcntl(sock,F_GETFL,&flag);
90.         flag|=O_NONBLOCK;
91.         fcntl(sock,F_SETFL,flag);
92.         socklen_t socklen;
93.         while(1)
94.         {
95.         socklen=sizeof(sock_client);
96.         if(( csock=(accept(sock,(struct sockaddr*)&sock_client,&socklen)))>0)
97.            {
98.                 for(i=0;i<10000;i++)
99.            {
100.                 if(clientsock[i]==-1)
101.                 {
102.                 clientsock[i]=csock;
103.                 break;
104.                 }
105.            }
106.            mess_response(csock,sock_client);
107.            printf("accept success\n");
108.          }
109.         if(csock==-1)
110.         {
111.         if(errno==EAGAIN)
112.         recv_request(csock);
113.         else perror("accept call failed\n");
114.         }
115.         }
116.         close(csock);
117.         close(sock);
118. }
121. #include<server.h>
122. int init_net()
123. {
124. int sock;
125. struct sockaddr_in sockaddr;
126. bzero(&sockaddr,sizeof(sockaddr));
127. sockaddr.sin_family=AF_INET;
128. sockaddr.sin_port=htons(1234);
129. sockaddr.sin_addr.s_addr=htonl(INADDR_ANY);
130. if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
131. printf("socket error\n");
132. else printf("socket ok\n");
133. if((bind(sock,(struct sockaddr*)&sockaddr,sizeof(sockaddr)))==-1)
134.             {perror("bind error\n");}
135. else printf("bind ok\n");
136.      listen(sock,128);
137.              return sock;
138. }
141. #include<server.h>
142. int main()
143. {
144. server_start();
145. return 0;
146. }

复制代码

单历程服务端只符合简易情况下的需求。
单历程接纳非阻塞瓜代执行的策略让等待毗连和读取处理瓜代执行，但是如果服务器长时间为某个客户端处理业务，导致无法建立新毗连处理其他人的数据。
并发服务器-多历程服务器

多历程服务器是具备并发处理本领的服务器模子，可以并发毗连并发处理，为若干客户端提供服务。并发数目取决于历程数目，频繁创建和烧毁历程有庞大的体系开销。
多历程模子中有多个处理单元，为多对多模子。多历程模子中，子历程随客户端持续，链接乐成创建，客户端退出则子历程退出。僵尸历程接纳，无论是阻塞接纳还是非阻塞，都会影响毗连，所以我们让线程负责接纳。

1. #include<stdio.h>
2. #include<stdlib.h>
3. #include<sys/types.h>
4. #include<sys/stat.h>
5. #include<time.h>
6. #include<string.h>
7. #include<arpa/inet.h>
8. #include<sys/socket.h>
9. #include<fcntl.h>
10. #include<sys/types.h>
11. #include<sys/stat.h>
12. #include<errno.h>
13. #include<pthread.h>
14. #include<signal.h>
15. #include<sys/wait.h>
17. int init_net();
18. void mess_response(int,struct sockaddr_in);
19. int recv_request(int);
20. int start_server();
21. void* thread_wait(void* arg);
22. void sig_wait(int n);
25. #include<server.h>
26. int init_net()
27. {
28. int sock;
29. struct sockaddr_in sockaddr;
30. bzero(&sockaddr,sizeof(sockaddr));
31. sockaddr.sin_family=AF_INET;
32. sockaddr.sin_port=htons(1234);
33. sockaddr.sin_addr.s_addr=htonl(INADDR_ANY);
34. if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
35. printf("socket error\n");
36. else printf("socket ok\n");
37. if((bind(sock,(struct sockaddr*)&sockaddr,sizeof(sockaddr)))==-1)
38.             {perror("bind error\n");}
39. else printf("bind ok\n");
40.      listen(sock,128);
41.              return sock;
42. }
44. #include<server.h>
45. void mess_response(int so,struct sockaddr_in addr)
46. {
47.         char s[1024];
48.         char c[16];
49.         bzero(c,16);
50.         bzero(s,1024);
51.         inet_ntop(AF_INET,&addr.sin_addr,c,16);
52.          sprintf(s,"hi %s\n",c);
53.           int t=send(so,s,strlen(s),MSG_NOSIGNAL);
54.           if(t<0)perror("err");
55.           return;
56. }
58. #include<server.h>
59. int recv_request(int sock)
60. {
61.         char s[1024];
62.         char tim[1024];
63.         bzero(s,sizeof(s));
64.         bzero(tim,sizeof(tim));
65.         int len;
66.         time_t tp;
68.         while((len=recv(sock,s,sizeof(s),0))>0)
69.         {
70.         s[strlen(s)-1]='\0';
71.         if(strncmp(s,"time",strlen(s))==0)
72.         {
73.                 tp=time(NULL);
74.                 ctime_r(&tp,tim);
75.                 send(sock,tim,strlen(tim),MSG_NOSIGNAL);
76.         }
77.         else{
78.                 send(sock,"try again",9,MSG_NOSIGNAL);
79.         }
80.         bzero(s,sizeof(s));
81.         bzero(tim,sizeof(tim));
82.         }
83.                 printf("client sock %d  ,child process %d its exiting...\n",sock,getpid());
84.                 close(sock);
85.                 exit(sock);
86. return 0;
87. }
89. #include<server.h>
90. void sig_wait(int n)
91. {
92. pid_t zpid;
93. while((zpid=waitpid(-1,NULL,WNOHANG))!=-1)
94. {
95. if(zpid>0){
96. printf("thread wait success,zpid %d\n",zpid);
97. }
98. }}
101. #include<server.h>
102. void* thread_wait(void* arg)
103. {
104. struct sigaction act,oact;
105. pthread_detach(pthread_self());
106. act.sa_handler=sig_wait;
107. act.sa_flags=0;
108. sigemptyset(&act.sa_mask);
109. sigaction(SIGCHLD,&act,&oact);
110. sigprocmask(SIG_SETMASK,&act.sa_mask,NULL);
111. printf("wait thread 0x%x waiting..\n",(unsigned int)pthread_self());
112. while(1)
113. sleep(1);
114. pthread_exit(NULL);
115. }
118. #include<server.h>
119. int server_start()
120. {
121.         int sock,csock;
122.         struct sockaddr_in sock_client;
123.         int i;
124.         bzero(&sock_client,sizeof(sock_client));
125.         sock=init_net();
126.         printf("init ok\n");
127.         socklen_t socklen;
129.         sigset_t set,oset;
130.         sigemptyset(&set);
131.         sigaddset(&set,SIGCHLD);
132.         sigprocmask(SIG_SETMASK,&set,&oset);
133.         pthread_t tid;
134.         int err;
135.         if((err=pthread_create(&tid,NULL,thread_wait,NULL))>0){
136.         printf("wait thread create err:%s\n",strerror(err));
137.         exit(0);
138.         }
139.         pid_t pid;
140.         while(1)
141.         {
142.         socklen=sizeof(sock_client);
143.         if(( csock=(accept(sock,(struct sockaddr*)&sock_client,&socklen)))>0)
144.         {
145.             pid=fork();
146.             if(pid>0)
147.            {
148.           mess_response(csock,sock_client);
149.            printf("accept success\n");
150.          }
151.            else if(pid==0)
152.         {
153.         recv_request(csock);
154.         }
155.         else exit(0);
156.         }
157.         else {
158.         printf("accept error\n");
159.                 }
160.        }
161.         close(sock);
162.         return 0;
163. }
166. #include<server.h>
167. int main()
168. {
169. server_start();
170. return 0;
171. }

复制代码

多历程稳定性强，因为每个处理单元是一个历程，一个历程异常退出不会影响其他历程。
并发服务器-多线程服务器

稳定性较差，线程瓦解可能影响其他线程，但是开销小轻量级。（线程安全问题）
并发量取决于线程数目。
频繁创建烧毁历程有庞大的体系开销。
和多历程差不多。
多路IO复用服务器

IO复用技术又名多路IO转接技术，可以帮助开发者监听大量的sock。
sock监听技术，io监听技术。
select模子

写的是单历程的。

#include<sys/select.h>//头文件
fd_set set;//监听集合类型
FD_ZERO(&set);//初始化监听集合，将位码初始化为0
FD_SET(int sockfd,&set);//将sockfd在集合中对应的位设置成1
FD_CLR(int sockfd,&sest);//将sockfd在集合中的对应位设置为0
int code=FD_ISSET(int sock,&set);//返回sockfd在集合中位码
int ready=select(maxfd+1,fd_set* rd,fd_set* wr,fd_set* err,timeval* timeout);//监听函数，监听事件选择以集合为单位，批处理，timeout=NULL,阻塞监听,监听集合对应文件描述符表，所以在设置监听数目时要考虑设备描述符。
struct timeval* val;   val.secons=0; val.ms=0;//如果要非阻塞使用select,需要定义时间结构体并将时间成员初始化成0，如果需要select定时阻塞，用户自行设置时间在结构体中。

1. #include<unistd.h>
2. #include<stdlib.h>
3. #include<signal.h>
4. #include<time.h>
5. #include<sys/select.h>
6. #include<sys/socket.h>
7. #include<string.h>
8. #include<arpa/inet.h>
9. int main()
10. {
11.         //sock的就绪数量
12.         int socknum;
13.         //存储客户端sock
14.         int sockarry[1020];
15.         //最大的描述符
16.         int maxfd;
17.         int ssock;
18.         int csock;
19.         //初始化客户端sock数组
20.         int i;
21.         for(i=0;i<1020;i++)
22.         {
23.         sockarry[i]=-1;
24.         }
25.         //初始化网络
26.         struct sockaddr_in saddr,caddr;
27.         saddr.sin_family=AF_INET;
28.         saddr.sin_port=htons(1234);
29.         saddr.sin_addr.s_addr=htonl(INADDR_ANY);
30.         if((ssock=socket(AF_INET,SOCK_STREAM,0))==-1)
31.         {
32.         perror("sock init error\n");
33.         }
34.         bind(ssock,(struct sockaddr*)&saddr,sizeof(saddr));
35.         listen(ssock,128);
36.         maxfd=ssock;
37.         //监听集合
38.         fd_set set,oset;
39.         //初始化监听集合
40.         FD_ZERO(&set);
41.         FD_SET(ssock,&set);
42.         socklen_t addrlen;
43.         //初次连接回复
44.         char response[1500];
45.         char cip[16];
46.         char buff[1024];
47.         bzero(response,1500);
48.         bzero(cip,16);
49.         bzero(buff,1024);
50.         //时间
51.         char timebuff[1024];
52.         time_t tp;
54.         int len;
55.         printf("server running\n");
56.         //轮询监听
57.         while(1)
58.         {
59.         oset=set;
60.         if((socknum=select(maxfd+1,&oset,NULL,NULL,NULL))==-1)
61.         perror("select() failed");
62.     while(socknum)
63.         {
64.         //是severfd
65.         if(FD_ISSET(ssock,&oset))
66.         {
67.         addrlen=sizeof(caddr);
68.         csock=accept(ssock,(struct sockaddr*)&caddr,&addrlen);
69.         //首次连接成功返回信息
70.         inet_ntop(AF_INET,&caddr.sin_addr.s_addr,cip,16);
71.         sprintf(response,"hi %s",cip);
72.         send(csock,response,strlen(response),MSG_NOSIGNAL);
73.         bzero(response,sizeof(response));
74.         //设置监听，存入数组
75.         FD_SET(csock,&set);
76.         for( i=0;i<1020;i++)
77.         {
78.         if(sockarry[i]==-1)
79.         {
80.         sockarry[i]=csock;
81.         break;
82.         }
83.         }
84.         //更新最大sockfd
85.         if(maxfd<csock)maxfd=csock;
86.         //将oset设置为0
87.         FD_CLR(ssock,&oset);
88.         }
89.         //是clientfd
90.         else
91.         {
92.         i=0;
93.         //遍历sockarry数组，查找就绪的csock并处理
94.         for(i;i<1020;i++)
95.         {
96.         if(sockarry[i]!=-1)
97.         if(FD_ISSET(sockarry[i],&oset))
98.         {
99.         //读取处理数组
100.         if((len=recv(sockarry[i],buff,sizeof(buff),0))>0)
101.         {
102.         buff[strlen(buff)-1]='\0';
103.         if((strcmp(buff,"time"))==0)
104.         {
105.         bzero(timebuff,1024);
106.         tp=time(NULL);
107.         ctime_r(&tp,timebuff);
108.         send(sockarry[i],timebuff,strlen(timebuff),MSG_NOSIGNAL);
109.         }
110.         else{
111.         send(sockarry[i],"try again",10,MSG_NOSIGNAL);
112.         }
113.         bzero(buff,1024);
114.         FD_CLR(sockarry[i],&oset);
115.         }
116.         if(len==0)
117.         {
118.         //客户端退出，在监听中删除，在组中删除
119.         FD_CLR(sockarry[i],&set);
120.         FD_CLR(sockarry[i],&oset);
121.         close(sockarry[i]);
122.         sockarry[i]=-1;
123.         }
124.         break;
125.         }
126.         }
127.         }
128.         socknum--;
129.         }
130.         }
131.         close(ssock);
132.         return 0;
133. }

复制代码

长处：
1.使用比力简单，相识监听集合以及IO复用机制即可使用，帮助用户完成少量sock的网络事件监听
2.跨平台兼容性比力好，在各个体系语言均有select支持
3.select支持微妙级定时，可以满意一些特定需求
缺点：
1.select无法满意大监听需求，最大监听数1024
2.轮询监听，随着轮询数目的增大，io处理性能呈线性下降
3.select监听到停当后只返回停当的数目，需要用户自行遍历查找停当的sock
4.需要用户举行传入传出分离设置
5.随着select的持续使用，会有庞大的开销和挂载开销
6.监听数目比力少，其次设置监听不机动，无法针对不同的sock设置不同的监听
poll模子

长处：
1.监听事件的种类丰富，对监听与停当举行了传入传出分离，无需用户分离
2.poll支持用户自定义长度结构体数组作为集合，突破了1024限定（轮询）
缺点：
1.轮询问题
2.拷贝开销挂载开销
3.只返回停当需要用户自行遍历查找停当的sock
4.只支持毫秒级别定时
5.在某些特定的Linux版本才可以使用
struct pollfd listen_array[4096];//监听数组，还可以帮助用户存储sock
listen_array[0].fd=sock;//如果需要监听则设置为某个sock，取消监听设置为-1
listen_arry[0].events=POLLIN|POLLOUT|POLLERR;//设置要监听的事件
listen_arry[0],revents;//如果监听的sock停当，体系将停当事件传到revents中
int readycode=poll(listen_array);//timeout -1阻塞 0非阻塞 >0定时阻塞

1. #include<stdio.h>
2. #include<unistd.h>
3. #include<stdlib.h>
4. #include<signal.h>
5. #include<time.h>
6. #include<sys/select.h>
7. #include<sys/socket.h>
8. #include<poll.h>
9. #include<string.h>
10. #include<arpa/inet.h>
11. int main()
12. {
13.         //sock的就绪数量
14.         int socknum;
15.         //存储客户端sock
16.         struct pollfd sockarry[4096];
17.         int ssock;
18.         int csock;
19.         //初始化客户端sock数组
20.         int i;
21.         for(i=0;i<4096;i++)
22.         {
23.         sockarry[i].fd=-1;
24.         sockarry[i].events=POLLIN;
25.         }
26.         //初始化网络
27.         struct sockaddr_in saddr,caddr;
28.         saddr.sin_family=AF_INET;
29.         saddr.sin_port=htons(1234);
30.         saddr.sin_addr.s_addr=htonl(INADDR_ANY);
31.         if((ssock=socket(AF_INET,SOCK_STREAM,0))==-1)
32.         {
33.         perror("sock init error\n");
34.         }
35.         bind(ssock,(struct sockaddr*)&saddr,sizeof(saddr));
36.         listen(ssock,128);
37.          //监听集合
38.         sockarry[0].fd=ssock;
39.         socklen_t addrlen;
40.         //初次连接回复
41.         char response[1500];
42.         char cip[16];
43.         char buff[1024];
44.         bzero(response,1500);
45.         bzero(cip,16);
46.         bzero(buff,1024);
47.         //时间
48.         char timebuff[1024];
49.         time_t tp;
51.         int len;
52.         printf("server running\n");
53.         //轮询监听
54.         while(1)
55.         {
56.         if((socknum=poll(sockarry,4096,-1))==-1)
57.         perror("poll() failed");
58.         while(socknum)
59.         {
60.         //是severfd
61.         if(sockarry[0].revents==POLLIN)
62.         {
63.         addrlen=sizeof(caddr);
64.         csock=accept(ssock,(struct sockaddr*)&caddr,&addrlen);
65.         //首次连接成功返回信息
66.         inet_ntop(AF_INET,&caddr.sin_addr.s_addr,cip,16);
67.         sprintf(response,"hi %s",cip);
68.         send(csock,response,strlen(response),MSG_NOSIGNAL);
69.         bzero(response,sizeof(response));
70.         //设置监听，存入数组
71.         for( i=1;i<4096;i++)
72.         {
73.         if(sockarry[i].fd==-1)
74.         {
75.         sockarry[i].fd=csock;
76.         break;
77.         }
78.         }
79.         //就绪处理
80.         sockarry[0].revents=0;
81.         }
82.         //是clientfd
83.         else
84.         {
85.         i=1;
86.         //遍历sockarry数组，查找就绪的csock并处理
87.         for(i;i<4096;i++)
88.         {
89.         if(sockarry[i].fd!=-1)
90.         if(sockarry[i].revents==POLLIN)
91.         {
92.         //读取处理数组
93.         if((len=recv(sockarry[i].fd,buff,sizeof(buff),0))>0)
94.         {
95.         buff[strlen(buff)-1]='\0';
96.         if((strcmp(buff,"time"))==0)
97.         {
98.         bzero(timebuff,1024);
99.         tp=time(NULL);
100.         ctime_r(&tp,timebuff);
101.         send(sockarry[i].fd,timebuff,strlen(timebuff),MSG_NOSIGNAL);
102.         }
103.          else{
104.         send(sockarry[i].fd,"try again",10,MSG_NOSIGNAL);
105.         }
106.         bzero(buff,1024);
107.         sockarry[i].revents=0;
108.         }
109.         if(len==0)
110.         {
111.         //客户端退出，在监听中删除，在组中删除
112.         close(sockarry[i].fd);
113.         sockarry[i].fd=-1;
114.         sockarry[i].revents=0;
115.         }
116.         break;
117.         }
118.         }
119.         }
120.         socknum--;
121.         }
122.         }
123.         close(ssock);
124.         return 0;
125. }

复制代码

用ulimit -a检察一下，如果小于4096，那么创建的sockarray会报错。

epoll模子

整合了select和poll的优势，而且优化了问题
epoll使用红黑树作为监听集合（监听树）
int epfd=epoll_create(int treeMax);//创建监听树，参数为巨细，返回值指向树的描述符
struct epolevent node;
node.data.fd=sock;
node.events=EPOLLIN|EPOLLOUT|EPOLLERR;
epoll_ctl(epfd,EPOLL_CTL_ADD,sock,struct epollevent* node);//添加节点
epoll_ctl(epfd,EPOLL_CTL_DEL,sock,NULL);//删除节点
epoll_ctl(epfd,EPOLL_CTL_MOD,sock,&node);//修改只能监听的事件，无法修改sock
struct epollevent ready_arry[Max];//用户空间定义停当队列（数组）
int readynode=epoll_wait(epfd,ready_arry,Max,-1);//Max停当最大数，树巨细=停当队列巨细=最大停当数
epoll监听树直接创建于内核，然后节点放入epoll等待队列，然后停当后弹出到停当链表（双向链表结构体，内核），然后从内核空间拷贝到用户空间，然后epoll监听到停当直接返回停当节点(sock)，用户遍历处理这些sock即可。
epoll不用担心轮询问题，所以没有监听限定，可以监听体系最大描述符数目，并没有多余开销
epoll不存在轮询问题，无需担心监听数目增大，体系开销增大。
epoll直接返回停当的sock，用户直接处理即可。
epoll监听集合在内核层，所以不会出现重复拷贝和重复挂载的问题，包管每个节点只拷贝一次，只挂载一次。
epoll与poll一样，监听的事件更丰富，而后设置监听比力机动，可以对不同的sock设置不同的事件监听。
作为监听模子，select,poll,epoll,epoll监听本领最强，但是处理本领而言(与监听模子无关)
监听部门(通过io复用技术监听管理有效毗连)
处理部门(并发处理)，又快又好的将请叱责部处理掉(快速反应，进步体验)
epoll的监听模式(水平触发模式EPOLLLT 边沿触发模式EPOLLET)EPOLLONTSHOT
epoll是线程安全的，epoll_ctl函数内部自带互斥锁，所以一个线程在访问修改树节点时，其他线程无法挂起等待
EPOLL+线程池服务器(满意高并发需求)

线程池技术：
预创建原则，线程池内部预备线程备用，不宜过多
线程应该重用性，可以一对多处理使命或服务不同的客户端
处理单元(线程)数目并不固定，动态扩容与缩减(使命量)
计划机动的使命通报方式与使命接口，线程可以执行不同种类的使命，不能将线程工作固定
线程池技术多为线程容器
thread_poll_create(int max,int min,int qmax);
int thread_producer_add(pool_t* pt,business_t bs);//添加一次业务向队列(生产者)
void* thread_customer(void* arg);//消耗者线程使命，等待队列，循环获取业务并执行
void* thread_manager(void* arg);//检察线程池阈值，动态扩容缩减线程
int net_init();//服务器网络初始化
int first_response();//毗连乐成初次响应
int epoll_init();//epoll创建初始化
int epoll_listen();//主线程循环监听sock事件，并根据停当添加使命
void* accept_business(void* arg);//tcp毗连业务
void* response_business(voiod* arg);//响应处理业务
if_thread_alive(pthread_t tid);//测试线程，返回0表现线程失效，1表现有效

1. #include<string.h>
2. #include<stdio.h>
3. #include<unistd.h>
4. #include<stdlib.h>
5. #include<sys/stat.h>
6. #include<sys/types.h>
7. #include<fcntl.h>
8. #include<sys/socket.h>
9. #include<arpa/inet.h>
10. #include<pthread.h>
11. #include<sys/epoll.h>
12. #include<time.h>
13. #include<signal.h>
14. #include<errno.h>
15. #define EPOLL_MAX 190000
16. int epfd;//监听树的描述符
17. //business_t业务类型
18. typedef struct
19. {
20. void* (*task)(void* arg);
21. void* arg;
22. }business_t;
23. //pool_t线程池类型
24. typedef struct
25. {
26. //线程池开关
27. int thread_shutdown;
28. //线程池最大线程数
29. int thread_max;
30. //线程池最小线程数
31. int thread_min;
32. //存活有效的线程数量
33. int thread_alive;
34. //繁忙线程数量
35. int thread_busy;
36. //缩减码
37. int exit_code;
38. //环形任务队列
39. business_t* queue;
40. int front;
41. int rear;
42. int max;
43. int cur;
44. //互斥锁
45. pthread_mutex_t lock;
46. //生产者条件变量
47. pthread_cond_t Not_Full;
48. //消费者条件变量
49. pthread_cond_t Not_Empty;
50. //消费者tid数组
51. pthread_t* ctids;
52. //管理者线程io
53. pthread_t mtid;
54. }pool_t;
55. pool_t* thread_pool_create(int tmax,int tmin,int qmax);
56. int thread_producer_add(pool_t* pt,business_t bs);
57. void* thread_customer(void* arg);
58. int if_thread_alive(pthread_t tid);
59. void* thread_mananger(void* arg);
60. int net_init(void);
61. int first_response(int sock,struct sockaddr_in caddr);
62. int epoll_init(int sock);
63. int epoll_listen(pool_t* pt,int sock);
64. void* accept_business(void*);
65. void* recv_business(void*);
67. #include<pool.h>
68. void* accept_business(void* arg)
69. {
70.         int sock=*(int*)arg;
71.         int csock;
72.         struct sockaddr_in caddr;
73.         char buffer[16];
74.         bzero(buffer,sizeof(buffer));
75.         socklen_t addrlen=sizeof(caddr);
76.         if((csock=accept(sock,(struct sockaddr*)&caddr,&addrlen))==-1)
77.                 perror("accept_business,accept failed");
78.         first_response(csock,caddr);
79.         //设置监听
80.         struct epoll_event node;
81.         node.data.fd=csock;
82.         node.events=EPOLLIN|EPOLLET;
83.         epoll_ctl(epfd,EPOLL_CTL_ADD,csock,&node);
84.         inet_ntop(AF_INET,&caddr.sin_addr.s_addr,buffer,16);
85.         printf("customer 0x%x execl accept_business success,client ip %s,client port %d\n",(unsigned int)pthread_self(),buffer,ntohs(caddr.sin_port));
86.         return NULL;
87. }
89.     #include<pool.h>
90.     int if_thread_alive(pthread_t tid)
91.     {
92.     int err;
93.     err=pthread_kill(tid,0);
94.     if(err==ESRCH)
95.     return 0;
96.     else return 1;
97.     }
99. #include<pool.h>
100. void* recv_business(void* arg)
101. {
102.         int sock=*(int*)arg;
103.         //读取请求数据，使用非阻塞，当前缓冲区无可读数据立即返回
104.         char buffer[1024];
105.         char timebuf[1024];
106.         time_t tp;
107.         int recvlen;
108.         bzero(buffer,sizeof(buffer));
109.         while((recvlen=recv(sock,buffer,sizeof(buffer),MSG_DONTWAIT))>0)
110.         {
111.                 //检测关键字，处理请求
112.                 buffer[strlen(buffer)-1]='\0';
113.                 if((strcmp(buffer,"time"))==0){
114.                         bzero(timebuf,1024);
115.                         tp=time(NULL);
116.                         ctime_r(&tp,timebuf);
117.                         send(sock,timebuf,strlen(timebuf),MSG_NOSIGNAL);
118.                         printf("recv_business execl success,response time\n");
119.                 }
120.                 else{
121.                         send(sock,"Please try again",17,MSG_NOSIGNAL);
122.                         printf("customer 0x%x recv_business execl success,reponse tryagain\n",(unsigned int)pthread_self());
123.                 }
124.         }
125.         if(recvlen==0){
126.                 //删除监听
127.                 epoll_ctl(epfd,EPOLL_CTL_DEL,sock,NULL);
128.                 printf("client %d exit,close csock\n",sock);
129.                 close(sock);
130.                 printf("customer 0x%xrecv_business execl success, client exit\n",(unsigned int)pthread_self());
131.         }
132.         if(recvlen==-1){
133.                 if(errno==EAGAIN){
134.                         //非阻塞返回
135.                 }
136.                 else perror("recv_bussiness recv call fialed");
137.         }
138. return NULL;
139. }
141. #include<pool.h>
142. extern int epfd;
143. int epoll_init(int sock)
144. {
145. if((epfd=epoll_create(EPOLL_MAX))==-1)
146. perror("create failed");
147. struct epoll_event node;
148. node.data.fd=sock;
149. node.events=EPOLLIN|EPOLLET;
150. epoll_ctl(epfd,EPOLL_CTL_ADD,sock,&node);
151. //创建监听树并将seversock设置成监听读事件
152. printf("server epoll success\n");
153. return 0;
154. }
156. #include<pool.h>
157. void* thread_customer(void* arg)
158. {
159.         //接收参数
160.         pool_t* pt=(pool_t*)arg;
161.         business_t bs;
162.         pthread_detach(pthread_self());
163.         //循环等待任务并处理
164.         printf("customer thread 0x%x,wait business\n",(unsigned int)pthread_self());
165.         while(pt->thread_shutdown)
166.         {
167.                 pthread_mutex_lock(&pt->lock);
168.                 while(pt->cur==0)
169.                 {
170.                         pthread_cond_wait(&pt->Not_Empty,&pt->lock);
171.                         if(!pt->thread_shutdown){
172.                                 printf("customer 0x%x,thread_shutdown %d,customer exiting..\n",(unsigned int)pthread_self(),pt->thread_shutdown);
173.                                 pthread_mutex_unlock(&pt->lock);
174.                                 pthread_exit(NULL);
175.                         }
176.                         if(pt->exit_code>0){
177.                                 printf("manager kill customer 0x%x success\n",(unsigned int)pthread_self());
178.                                 --(pt->thread_alive);
179.                                 --(pt->exit_code);
180.                                 pthread_mutex_unlock(&pt->lock);
181.                                 pthread_exit(NULL);
182.                         }
183.                 }
184.                 //获取任务
185.                 bs.task=pt->queue[pt->rear].task;
186.                 bs.arg=pt->queue[pt->rear].arg;
187.                 --(pt->cur);
188.                 pt->rear=(pt->rear+1)%pt->max;
189.                 ++(pt->thread_busy);
190.                 pthread_mutex_unlock(&pt->lock);
191.                 //唤醒生产者
192.                 pthread_cond_signal(&pt->Not_Full);
193.                 //执行任务
194.                 bs.task(bs.arg);
195.                 pthread_mutex_lock(&pt->lock);
196.                 --(pt->thread_busy);
197.                 pthread_mutex_unlock(&pt->lock);
198.         }
199.         printf("customer 0x%x,thread_shutdown %d,customer exiting..\n",(unsigned int)pthread_self(),pt->thread_shutdown);
200.         pthread_exit(NULL);
201. }
203. #include<pool.h>
204. void* thread_mananger(void* arg)
205. {
206.         pool_t* pt=(pool_t*)arg;
207.         int alive,busy,cur;
208.         int flag;
209.         int add;
210.         int fd;
211.         if((access("manager_information",F_OK))==0)
212.                 unlink("manager_information");
213.         fd=open("manager_information",O_RDWR|O_CREAT,0664);
214.         char result[4096];
215.         while(pt->thread_shutdown){
216.                 pthread_mutex_lock(&pt->lock);
217.                 alive=pt->thread_alive;
218.                 busy=pt->thread_busy;
219.                 cur=pt->cur;
220.                 pthread_mutex_unlock(&pt->lock);
221.                 bzero(result,sizeof(result));
222.                 sprintf(result,"manager 0x%x,alive %d ,busy %d,idel %d busy/alive %.2f%% alive/max %.2f%%\n",alive,busy,alive-busy,(double)busy/alive*100,(double)alive/pt->thread_max*100);
223.                 write(fd,result,strlen(result));
224.                 //扩容 thread_min作为扩容与缩减量
225.                 //1.任务数量cur>=alive-busy
226.                 //2.使用百分比扩容，如果忙线程占存活线程的70%
227.                 //3.扩容不能超出最大阈值thread_max
228.                 int err;
229.                 if((cur>=alive-busy||(double)busy/alive*100>=70)&&alive+pt->thread_min<=pt->thread_max)
230.                 {
231.                         //ctids,如果为0直接使用，非0要测试线程是否存活
232.                         //遍历tids查找可用位置，并且创建新消费者
233.                         for(flag=0,add=0;flag<pt->thread_max&&add<pt->thread_min;flag++)
234.                         {
235.                                 if(pt->ctids[flag]==0||!if_thread_alive(pt->ctids[flag]))
236.                                 {
237.                                         if((err=pthread_create(&pt->ctids[flag],NULL,thread_customer,(void*)pt))>0)
238.                                                 printf("manager create new customer failed:%s\n",strerror(err));
239.                                         add++;
240.                                         pthread_mutex_lock(&pt->lock);
241.                                         ++(pt->thread_alive);
242.                                         pthread_mutex_unlock(&pt->lock);
243.                                  }
244.                         }
245.                 }
246.                 //缩减条件：闲线程是忙线程的倍数，缩减不允许小于最小阈值
247.                 if(busy*2<=alive-busy&&alive-pt->thread_min>=pt->thread_min)
248.                 {
249.                         //如何缩减
250.                         //1.管理者缩减cance,改造ctids,除了存储tid,还要存储记录线程状态，管理者遍历而后cancel取消闲线程
251.                         //2.配合缩减，消费者退出码，唤醒闲消费者，消费者检查退出码，而后自行退出
252.                         pt->exit_code=pt->thread_min;
253.                         int i;
254.                         for(i=0;i<pt->thread_min;i++)
255.                                 pthread_cond_signal(&pt->Not_Empty);
256.                 }
257.                 sleep(1);
258.         }
259.         printf("manager 0x%x exit.\n",(unsigned int)pthread_self());
260.         pthread_exit(NULL);
261. }
263. #include<pool.h>
264. //生产者监听模型
265. int epoll_listen(pool_t* pt,int sock)
266. {
267.         int readycode;
268.         struct epoll_event readyarray[EPOLL_MAX];
269.         int i;
270.         business_t bs;
271.         while(pt->thread_shutdown)
272.         {
273.                 if((readycode=epoll_wait(epfd,readyarray,EPOLL_MAX,-1))==-1)
274.                         perror("epoll_listen,epoll_wait call failed");
275.                 else{
276.                         i=0;
277.                         while(readycode)
278.                         {
279.                                 //判断就绪
280.                                 if(readyarray[i].data.fd==sock){
281.                                         //serversock ready
282.                                         bs.task=accept_business;
283.                                         bs.arg=(void*)&readyarray[i].data.fd;
284.                                         thread_producer_add(pt,bs);
285.                                         printf("thread producer 0x%x add accept business..\n",(unsigned int)pthread_self());
286.                                 }
287.                                 else{
288.                                         //clientsock ready
289.                                         bs.task=recv_business;
290.                                         bs.arg=(void*)&readyarray[i].data.fd;
291.                                         thread_producer_add(pt,bs);
292.                                         printf("thrad producer 0x%x add recv business..\n",(unsigned int)pthread_self());
293.                                 }
294.                                 --readycode;
295.                                 ++i;
296.                         }}
297.         }
298.         printf("producer is done..\n");
299.         return 0;
300. }
302. #include<pool.h>
303. pool_t* thread_pool_create(int tmax,int tmin,int qmax)
304. {
305.         //对线程池类初始化,申请空间，按最小阈值创建消费者并创建管理者
306.         pool_t* pt=NULL;
307.         if((pt=malloc(sizeof(pool_t)))==NULL)
308.                 perror("thread_pool_create,malloc pool failed");
309.         pt->thread_shutdown=1;
310.         pt->thread_max=tmax;
311.         pt->thread_min=tmin;
312.         pt->thread_alive=0;
313.         pt->thread_busy=0;
314.         pt->exit_code=0;
315.         //创建队列
316.         if((pt->queue=malloc(sizeof(business_t)*qmax))==NULL)
317.                 perror("thread_pool_crreate,malloc queue failed");
318.         pt->front=0;
319.         pt->rear=0;
320.         pt->max=qmax;
321.         pt->cur=0;
322.         if((pt->ctids=malloc(sizeof(pthread_t)*tmax))==NULL)
323.                 perror("thread_pool_create,malloc ctids failed");
324.         //初始化ctids,0
325.         bzero(pt->ctids,sizeof(pthread_t)*tmax);
326.         if(pthread_mutex_init(&(pt->lock),NULL)!=0||pthread_cond_init(&(pt->Not_Full),NULL)!=0||pthread_cond_init(&(pt->Not_Empty),NULL)!=0){
327.                 printf("thread_pool_create,init lock or cond failed\n");
328.         }
329.         //预创建消费者
330.         int err;
331.         int i;
332.         for(i=0;i<tmin;i++){
333.                 if((err=pthread_create(&pt->ctids[i],NULL,thread_customer,pt))>0)
334.                         printf("thread_pool_create,create customer failed:%s\n",strerror(err));
335.                 else ++(pt->thread_alive);
336.         }
337.         //管理线程
338.         if((err=pthread_create(&pt->mtid,NULL,thread_mananger,pt))>0)
339.                 printf("thread_pool_create,cretate mannager failed:%s\n",strerror(err));
340.         return pt;
341. }
343. #include<pool.h>
344. int first_response(int sock,struct sockaddr_in caddr)
345. {
346. char cip[16];
347. char response[1500];
348. bzero(cip,16);
349. bzero(response,sizeof(response));
350. inet_ntop(AF_INET,&caddr.sin_addr,cip,16);
351. sprintf(response,"hi,%s connection server host  success\n",cip);
352. if((send(sock,response,strlen(response),0))==-1)
353. perror("first_response,send failed");
354. return 0;
355. }
357. #include<pool.h>
358. int net_init(void)
359. {
360. int sock;
361. struct sockaddr_in saddr;
362. bzero(&saddr,sizeof(saddr));
363. saddr.sin_family=AF_INET;
364. saddr.sin_port=htons(1234);
365. saddr.sin_addr.s_addr=htonl(INADDR_ANY);
366. if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
367. perror("sock failed");
368. if((bind(sock,(struct sockaddr*)&saddr,sizeof(saddr)))==-1)
369. perror("bind failed");
370. if((listen(sock,128))==-1)
371. perror("listen failed");
372. printf("srver init success\n");
373. return sock;
374. }
376. #include<pool.h>
377. int thread_producer_add(pool_t* pt,business_t bs)
378. {
379.         //生产者任务
380.         pthread_mutex_lock(&pt->lock);
381.         if(pt->thread_shutdown)
382.         {
383.                 while(pt->cur==pt->max)
384.                 {
385.                         pthread_cond_wait(&pt->Not_Full,&pt->lock);
386.                         if(!pt->thread_shutdown){
387.                                 printf("cusomter thread 0x%x,shutdown %d,thread exit..\n",(unsigned int)pthread_self(),pt->thread_shutdown);
388.                                 pthread_mutex_unlock(&pt->lock);
389.                                 pthread_exit(NULL);
390.                         }
391.                 }
392.                 //添加一次业务
393.                 pt->queue[pt->front].task=bs.task;
394.                 pt->queue[pt->front].arg=bs.arg;
395.                 ++(pt->cur);
396.                 pt->front=(pt->front+1)%pt->max;
397.                 pthread_mutex_unlock(&pt->lock);
398.                 pthread_cond_signal(&pt->Not_Empty);
400. }
401. pthread_mutex_unlock(&pt->lock);
402. return 0;
403. }
405. #include<pool.h>
406. int main()
407. {
408.         int serverfd=net_init();
409.         epoll_init(serverfd);
410.         pool_t* pt=thread_pool_create(100,10,1000);
411.         epoll_listen(pt,serverfd);
412.         return 0;
413. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。