linux 2.6内核epoll用法举例

 

1. linux 2.6内核epoll用法举例说明(续)--给echo服务器增加读线程池
4. 上篇文章使用linux内核2.6 提供的epoll机制实现了一个反应式echo服务器，使用反应式服务器的最大好处就是可以按cpu的数量来配置线程池内线程的线程数而不是根据客户端的并发量配置线程池。我是第一次使用pthread库来写线程池，使用的是工作队列方式的线程池。我感觉作队列方式的线程池可以当成一种设计模式来用的，在很多平台上都是可以按这种方式来实现线程池，从win32 ,unix到jvm都是适用的
6.  
8. #include
10. #include
12. #include
14. #include
16. #include
18. #include
20. #include
22. #include
24. #include
26.  
28. #define MAXLINE 10
30. #define OPEN_MAX 100
32. #define LISTENQ 20
34. #define SERV_PORT 5555
36. #define INFTIM 1000
38.  
40. //线程池任务队列结构体
42. struct task{
44.   int fd;            //需要读写的文件描述符
46.   struct task *next; //下一个任务
48. };
50.  
52. //用于读写两个的两个方面传递参数
54. struct user_data{
56.   int fd;
58.   unsigned int n_size;
60.   char line[MAXLINE];
62. };
64.  
66. //线程的任务函数
68. void * readtask(void *args);
70. void * writetask(void *args);
72.  
74.  
76. //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
78. struct epoll_event ev,events[20];
80. int epfd;
82. pthread_mutex_t mutex;
84. pthread_cond_t cond1;
86. struct task *readhead=NULL,*readtail=NULL,*writehead=NULL;
88.  
90. void setnonblocking(int sock)
92. {
94.      int opts;
96.      opts=fcntl(sock,F_GETFL);
98.      if(opts<0)
100.      {
102.           perror("fcntl(sock,GETFL)");
104.           exit(1);
106.      }
108.     opts = opts|O_NONBLOCK;
110.      if(fcntl(sock,F_SETFL,opts)<0)
112.      {
114.           perror("fcntl(sock,SETFL,opts)");
116.           exit(1);
118.      }   
120. }
122.  
124. int main()
126. {
128.      int i, maxi, listenfd, connfd, sockfd,nfds;
130.      pthread_t tid1,tid2;
132.     
134.      struct task *new_task=NULL;
136.      struct user_data *rdata=NULL;
138.      socklen_t clilen;
140.     
142.      pthread_mutex_init(&mutex,NULL);
144.      pthread_cond_init(&cond1,NULL);
146.      //初始化用于读线程池的线程
148.      pthread_create(&tid1,NULL,readtask,NULL);
150.      pthread_create(&tid2,NULL,readtask,NULL);
152.     
154.      //生成用于处理accept的epoll专用的文件描述符   
156.      epfd=epoll_create(256);
158.  
160.      struct sockaddr_in clientaddr;
162.      struct sockaddr_in serveraddr;
164.      listenfd = socket(AF_INET, SOCK_STREAM, 0);
166.      //把socket设置为非阻塞方式
168.      setnonblocking(listenfd);
170.      //设置与要处理的事件相关的文件描述符
172.      ev.data.fd=listenfd;
174.      //设置要处理的事件类型
176.      ev.events=EPOLLIN|EPOLLET;
178.      //注册epoll事件
180.      epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
182.     
184.      bzero(&serveraddr, sizeof(serveraddr));
186.      serveraddr.sin_family = AF_INET;
188.     
190.      char *local_addr="200.200.200.222";
192.      inet_aton(local_addr,&(serveraddr.sin_addr));//htons(SERV_PORT);
194.      serveraddr.sin_port=htons(SERV_PORT);
196.      bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
198.      listen(listenfd, LISTENQ);
200.     
202.      maxi = 0;
204.      for ( ; ; ) {
206.           //等待epoll事件的发生
208.           nfds=epoll_wait(epfd,events,20,500);
210.           //处理所发生的所有事件     
211.         for(i=0;i
213.         {
215.                if(events[i].data.fd==listenfd)
217.                {
219.                    
221.                     connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);
223.                     if(connfd<0){
225.                       perror("connfd<0");
227.                       exit(1);
229.                    }
231.                     setnonblocking(connfd);
233.                    
235.                     char *str = inet_ntoa(clientaddr.sin_addr);
236.                     std::cout<<"connec_ from >>"<
238.                     //设置用于读操作的文件描述符
240.                     ev.data.fd=connfd;
242.                     //设置用于注测的读操作事件
244.                  ev.events=EPOLLIN|EPOLLET;
246.                     //注册ev
248.                  epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
250.                }
252.             else if(events[i].events&EPOLLIN)
254.             {
256.                     printf("reading!/n");                
258.                     if ( (sockfd = events[i].data.fd) < 0) continue;
260.                     new_task=new task();
262.                     new_task->fd=sockfd;
264.                     new_task->next=NULL;
266.                     //添加新的读任务
268.                     pthread_mutex_lock(&mutex);
270.                     if(readhead==NULL)
272.                     {
274.                       readhead=new_task;
276.                       readtail=new_task;
278.                     }   
280.                     else
282.                     {   
284.                      readtail->next=new_task;
286.                       readtail=new_task;
288.                     }   
290.                    //唤醒所有等待cond1条件的线程
292.                     pthread_cond_broadcast(&cond1);
294.                     pthread_mutex_unlock(&mutex);  
296.               }
298.                else if(events[i].events&EPOLLOUT)
300.                {   
302.               rdata=(struct user_data *)events[i].data.ptr;
304.                  sockfd = rdata->fd;
306.                  write(sockfd, rdata->line, rdata->n_size);
308.                  delete rdata;
310.                  //设置用于读操作的文件描述符
312.                  ev.data.fd=sockfd;
314.                  //设置用于注测的读操作事件
316.                ev.events=EPOLLIN|EPOLLET;
318.                  //修改sockfd上要处理的事件为EPOLIN
320.                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
322.                }
324.                              
326.           }
328.          
330.      }
332. }
334. void * readtask(void *args)
336. {
338.    
340.    int fd=-1;
342.    unsigned int n;
344.    //用于把读出来的数据传递出去
346.    struct user_data *data = NULL;
348.    while(1){
350.         
352.         pthread_mutex_lock(&mutex);
354.         //等待到任务队列不为空
356.         while(readhead==NULL)
358.              pthread_cond_wait(&cond1,&mutex);
360.         
362.         fd=readhead->fd;
364.         //从任务队列取出一个读任务
366.         struct task *tmp=readhead;
368.         readhead = readhead->next;
370.         delete tmp;
372.         pthread_mutex_unlock(&mutex);
374.         data = new user_data();
376.         data->fd=fd;
378.         if ( (n = read(fd, data->line, MAXLINE)) < 0) {
380.            
382.            if (errno == ECONNRESET) {
384.              close(fd);
386.              
388.           } else
389.              std::cout<<"readline error"<
391.            if(data!=NULL)delete data;
393.         } else if (n == 0) {
395.             close(fd);
397.            printf("Client close connect!/n");
399.            if(data!=NULL)delete data;
401.         } else{
403.         
405.         data->n_size=n;
407.         //设置需要传递出去的数据
409.         ev.data.ptr=data;
411.         //设置用于注测的写操作事件
413.         ev.events=EPOLLOUT|EPOLLET;
415.         //修改sockfd上要处理的事件为EPOLLOUT
417.         epoll_ctl(epfd,EPOLL_CTL_MOD,fd,&ev);
419.        }
421.    }
423. }