这段代码中创建的子进程是如何工作的？

nicksean

1. #include <iostream>
   
2. #include <sys/socket.h>
   
3. #include <sys/epoll.h>
   
4. #include <netinet/in.h>
   
5. #include <arpa/inet.h>
   
6. #include <fcntl.h>
   
7. #include <unistd.h>
   
8. #include <stdio.h>
   
9. #include <errno.h>
   
10. #include <sys/types.h>
    
11. #include <sys/wait.h>
    
12. 
    
13. using namespace std;
    
14. 
    
15. #define MAXLINE 5
    
16. #define OPEN_MAX 100
    
17. #define LISTENQ 20
    
18. #define SERV_PORT 5000
    
19. #define INFTIM 1000
    
20. 
    
21. typedef struct task_t
    
22. {
    
23.     int fd;
    
24.     char buffer[100];
    
25.     int n;
    
26. }task_t;
    
27. 
    
28. int CreateWorker(int nWorker)
    
29. {
    
30.     if (0 < nWorker)
    
31.     {
    
32.         bool bIsChild;
    
33.         pid_t nPid;
    
34. 
    
35.         while (!bIsChild)
    
36.         {
    
37.             if (0 < nWorker)
    
38.             {
    
39.                 nPid = ::fork();
    
40.                 if (nPid > 0)
    
41.                 {
    
42.                     bIsChild = false;
    
43.                     --nWorker;
    
44.                 }
    
45.                 else if (0 == nPid)
    
46.                 {
    
47.                     bIsChild = true;
    
48.                     printf("create worker %d success!\n", ::getpid());
    
49.                 }
    
50.                 else
    
51.                 {
    
52.                     printf("fork error: %s\n", ::strerror(errno));
    
53.                     return -1;
    
54.                 }
    
55.             }
    
56.             else
    
57.             {
    
58.                 int nStatus;
    
59.                 if (-1 == ::wait(&nStatus))
    
60.                 {
    
61.                     ++nWorker;
    
62.                 }
    
63.             }
    
64.         }
    
65.     }
    
66. 
    
67.     return 0;
    
68. }
    
69. 
    
70. void setnonblocking(int sock)
    
71. {
    
72.     int opts;
    
73.     opts=fcntl(sock,F_GETFL);
    
74.     if(opts<0)
    
75.     {
    
76.         perror("fcntl(sock,GETFL)");
    
77.         exit(1);
    
78.     }
    
79.     opts = opts|O_NONBLOCK;
    
80.     if(fcntl(sock,F_SETFL,opts)<0)
    
81.     {
    
82.         perror("fcntl(sock,SETFL,opts)");
    
83.         exit(1);
    
84.     }   
    
85. }
    
86. 
    
87. int main()
    
88. {
    
89.     int i, maxi, listenfd, connfd, sockfd,epfd,nfds;
    
90.     ssize_t n;
    
91.     char line[MAXLINE];
    
92.     socklen_t clilen;
    
93.     struct epoll_event ev,events[20];
    
94. 
    
95.     struct sockaddr_in clientaddr;
    
96.     struct sockaddr_in serveraddr;
    
97.     listenfd = socket(AF_INET, SOCK_STREAM, 0);
    
98.        bzero(&serveraddr, sizeof(serveraddr));
    
99.     serveraddr.sin_family = AF_INET;
    
100.     char *local_addr="127.0.0.1";
     
101.     inet_aton(local_addr,&(serveraddr.sin_addr));//htons(SERV_PORT);
     
102.     serveraddr.sin_port=htons(SERV_PORT);
     
103.       // 地址重用
     
104.     int nOptVal = 1;
     
105.     socklen_t nOptLen = sizeof(int);
     
106.     if (-1 == ::setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &nOptVal, nOptLen))
     
107.     {
     
108.         return -1;
     
109.     }   
     
110.     setnonblocking(listenfd);
     
111.     bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
     
112.     listen(listenfd, LISTENQ);   
     
113.    
     
114.     CreateWorker(5);
     
115.    
     
116.     //把socket设置为非阻塞方式
     
117.    
     
118.     //生成用于处理accept的epoll专用的文件描述符
     
119.     epfd=epoll_create(256);   
     
120.     //设置与要处理的事件相关的文件描述符
     
121.     ev.data.fd=listenfd;
     
122.     //设置要处理的事件类型
     
123.     ev.events=EPOLLIN|EPOLLET;
     
124.     //ev.events=EPOLLIN;
     
125.     //注册epoll事件
     
126.     epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
     
127. 
     
128.      //CreateWorker(5);
     
129.      
     
130.     maxi = 0;
     
131.    
     
132.     task_t task;
     
133.     task_t *ptask;
     
134.     while(true)
     
135.     {
     
136.         //等待epoll事件的发生
     
137.         nfds=epoll_wait(epfd,events,20,500);
     
138.         //处理所发生的所有事件     
     
139.         for(i=0;i<nfds;++i)
     
140.         {
     
141.             if(events[i].data.fd==listenfd)
     
142.             {               
     
143.                 connfd = accept(listenfd,NULL, NULL);
     
144.                 if(connfd<0){                    
     
145.                     printf("connfd<0, listenfd = %d\n", listenfd);
     
146.                     printf("error = %s\n", strerror(errno));
     
147.                     exit(1);
     
148.                 }
     
149.                 setnonblocking(connfd);
     
150.                
     
151.                 //设置用于读操作的文件描述符
     
152.                 memset(&task, 0, sizeof(task));
     
153.                 task.fd = connfd;
     
154.                 ev.data.ptr = &task;
     
155.                 //设置用于注册的读操作事件
     
156.                 ev.events=EPOLLIN|EPOLLET;
     
157.                 //ev.events=EPOLLIN;
     
158.                 //注册ev
     
159.                 epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
     
160.             }
     
161.             else if(events[i].events&EPOLLIN)
     
162.             {
     
163.                 cout << "EPOLLIN" << endl;
     
164.                 ptask = (task_t*)events[i].data.ptr;
     
165.                 sockfd = ptask->fd;
     
166.                
     
167.                 if ( (ptask->n = read(sockfd, ptask->buffer, 100)) < 0) {
     
168.                     if (errno == ECONNRESET) {
     
169.                         close(sockfd);
     
170.                         events[i].data.ptr = NULL;
     
171.                     } else
     
172.                         std::cout<<"readline error"<<std::endl;
     
173.                 } else if (ptask->n == 0) {
     
174.                     close(sockfd);
     
175.                     events[i].data.ptr = NULL;
     
176.                 }
     
177.                 ptask->buffer[ptask->n] = '\0';
     
178.                 cout << "read " << ptask->buffer << endl;
     
179.                
     
180.                 //设置用于写操作的文件描述符                                
     
181.                 ev.data.ptr = ptask;
     
182.                 //设置用于注测的写操作事件
     
183.                 ev.events=EPOLLOUT|EPOLLET;
     
184.                                 
     
185.                 //修改sockfd上要处理的事件为EPOLLOUT
     
186.                 epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
     
187.             }
     
188.             else if(events[i].events&EPOLLOUT)
     
189.             {   
     
190.                 cout << "EPOLLOUT" << endl;
     
191.                 ptask = (task_t*)events[i].data.ptr;
     
192.                 sockfd = ptask->fd;
     
193.                
     
194.                 write(sockfd, ptask->buffer, ptask->n);
     
195.                
     
196.                 //设置用于读操作的文件描述符              
     
197.                 ev.data.ptr = ptask;
     
198.                
     
199.                 //修改sockfd上要处理的事件为EPOLIN
     
200.                 epoll_ctl(epfd,EPOLL_CTL_DEL,sockfd,&ev);
     
201.                 cout << "write " << ptask->buffer;
     
202.                 memset(ptask, 0, sizeof(*ptask));
     
203.                 close(sockfd);
     
204.             }
     
205.         }
     
206.     }
     
207.     return 0;
     
208. }
     

复制代码

nicksean

CreateWorker后5个子进程处理Epoll？