进程间通信的疑惑？

peng.1981.china

先说一下。 这是我们公司使用的一种方式， 使用共享内存，  
思路如下:
1. 启动主进程，根据要启动的  子进程的数量 * 单个进程的数据交换空间的大小 计算出共享内存的大小。 创建共享内存
2. 主进程 创建负责与子进程进行通信的子线程
3. 主进程 创建子进程，并为子进程分配共享内存
4. 系统初始化完成.
5. 主进程 接收客户端请求， 把请求分配 给子线程。
6. 子线程接收数据，写入共享内存， 并通知子进程进行处理。
7. 子进程唤醒，从共享内存读取数据。 子进程相应的数据处理， 并把处理结束写入共享内存， 通知主进程, 子进程休眠
8. 子线程读取数据，并发送数据到客户端
9. 下一次处理从第5步开始

mhz-ada

用pipe吧，把connfd发到预先创建的子进程中

ddvv

原帖由 converse 于 2009-3-11 21:23 发表
我建议你改成这样:
父进程创建监听socket,然后fork子进程,由操作系统决定由哪个子进程来进行处理,也就是说当有连接过来的时候由哪个子进程来处理.

现在你这种方式是由程序员来决定选择哪个子进程来处理.

意思是否是这样：

step 1: parent.fork()
step 2: parent.listen() child.listen()
step 3: connection coming
step 4: 操作系统决定是由parent.accept()还是child.accept()

？？

思一克

给你google来的一个参考

1. 
   
2. #ifndef AT_FDCWD
   
3. #define AT_FDCWD -100
   
4. #endif
   
5. 
   
6. #if defined(__i386__)
   
7. #define __NR_revokeat   325
   
8. #else
   
9. #error unsupported arch
   
10. #endif
    
11. 
    
12. int revokeat(int dfd, const char *path)
    
13. {
    
14.         return syscall(__NR_revokeat, dfd, path);
    
15. }
    
16. 
    
17. static void panic(const char *s)
    
18. {
    
19.         perror(s);
    
20.         exit(1);
    
21. }
    
22. 
    
23. /* I test here for __sun for lack of anything better, but I
    
24. * mean Solaris 2.6. The idea of undefining SCM_RIGHTS is
    
25. * to force the headers to behave BSD 4.3 way which I have
    
26. * tested to work.
    
27. *
    
28. * In general, if you have compilation errors, you might consider
    
29. * adding a test for your platform here.
    
30. */
    
31. #if defined(__sun)
    
32. #undef SCM_RIGHTS
    
33. #endif
    
34. 
    
35. #ifdef SCM_RIGHTS
    
36. 
    
37. /* It seems various versions of glibc headers (i.e.
    
38. * /usr/include/socketbits.h) miss one or more of these */
    
39. 
    
40. #ifndef CMSG_DATA
    
41. # define CMSG_DATA(cmsg) ((cmsg)->cmsg_data)
    
42. #endif
    
43. 
    
44. #ifndef CMSG_NXTHDR
    
45. # define CMSG_NXTHDR(mhdr, cmsg) __cmsg_nxthdr (mhdr, cmsg)
    
46. #endif
    
47. 
    
48. #ifndef CMSG_FIRSTHDR
    
49. # define CMSG_FIRSTHDR(mhdr) \
    
50.   ((size_t) (mhdr)->msg_controllen >= sizeof (struct cmsghdr)          \
    
51.    ? (struct cmsghdr *) (mhdr)->msg_control : (struct cmsghdr *) NULL)
    
52. #endif
    
53. 
    
54. #ifndef CMSG_ALIGN
    
55. # define CMSG_ALIGN(len) (((len) + sizeof (size_t) - 1) \
    
56.                          & ~(sizeof (size_t) - 1))
    
57. #endif
    
58. 
    
59. #ifndef CMSG_SPACE
    
60. # define CMSG_SPACE(len) (CMSG_ALIGN (len) \
    
61.                          + CMSG_ALIGN (sizeof (struct cmsghdr)))
    
62. #endif
    
63. 
    
64. #ifndef CMSG_LEN
    
65. # define CMSG_LEN(len)   (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
    
66. #endif
    
67. 
    
68. union fdmsg {
    
69.         struct cmsghdr h;
    
70.         char buf[CMSG_SPACE(sizeof(int))];
    
71. };
    
72. #endif
    
73. 
    
74. /* Tested to work on perl 5.005_03
    
75. *   Linux-2.2.14 glibc-2.0.7 (libc.so.6) i586  BSD4.4
    
76. *   Linux-2.0.38 glibc-2.0.7 (libc.so.6) i586  BSD4.4
    
77. *   SunOS-5.6, gcc-2.7.2.3, Sparc BSD4.3
    
78. * see also: linux/net/unix/af_unix.c
    
79. */
    
80. 
    
81. 
    
82. int
    
83. sendfd(sock_fd, send_me_fd)
    
84.         int sock_fd;
    
85.         int send_me_fd;
    
86. {
    
87.         int ret = 0;
    
88.         struct iovec  iov[1];
    
89.         struct msghdr msg;
    
90. 
    
91.         iov[0].iov_base = &ret;  /* Don't send any data. Note: der Mouse
    
92.                                   * <[email]mouse@Rodents.Montreal.QC.CA[/email]> says
    
93.                                   * that might work better if at least one
    
94.                                   * byte is sent. */
    
95.         iov[0].iov_len  = 1;
    
96. 
    
97.         msg.msg_iov     = iov;
    
98.         msg.msg_iovlen  = 1;
    
99.         msg.msg_name    = 0;
    
100.         msg.msg_namelen = 0;
     
101. 
     
102.         {
     
103. #ifdef SCM_RIGHTS
     
104.                 /* New BSD 4.4 way (ouch, why does this have to be
     
105.                  * so convoluted). */
     
106. 
     
107.                 union  fdmsg  cmsg;
     
108.                 struct cmsghdr* h;
     
109. 
     
110.                 msg.msg_control = cmsg.buf;
     
111.                 msg.msg_controllen = sizeof(union fdmsg);
     
112.                 msg.msg_flags = 0;
     
113. 
     
114.                 h = CMSG_FIRSTHDR(&msg);
     
115.                 h->cmsg_len   = CMSG_LEN(sizeof(int));
     
116.                 h->cmsg_level = SOL_SOCKET;
     
117.                 h->cmsg_type  = SCM_RIGHTS;
     
118.                 *((int*)CMSG_DATA(h)) = send_me_fd;
     
119. #else
     
120.                 /* Old BSD 4.3 way. Not tested. */
     
121.                 msg.msg_accrights = &send_me_fd;
     
122.                 msg.msg_accrightslen = sizeof(send_me_fd);
     
123. #endif
     
124. 
     
125.                 if (sendmsg(sock_fd, &msg, 0) < 0) {
     
126.                         ret = 0;
     
127.                 } else {
     
128.                         ret = 1;
     
129.                 }
     
130.         }
     
131.         /*fprintf(stderr,"send %d %d %d %d\n",sock_fd, send_me_fd, ret, errno);*/
     
132.         return ret;
     
133. }
     
134. 
     
135. int
     
136. recvfd(sock_fd)
     
137.         int sock_fd;
     
138. {
     
139.         int count;
     
140.         int ret = 0;
     
141.         struct iovec  iov[1];
     
142.         struct msghdr msg;
     
143. 
     
144.         iov[0].iov_base = &ret;  /* don't receive any data */
     
145.         iov[0].iov_len  = 1;
     
146. 
     
147.         msg.msg_iov = iov;
     
148.         msg.msg_iovlen = 1;
     
149.         msg.msg_name = NULL;
     
150.         msg.msg_namelen = 0;
     
151. 
     
152.         {
     
153. #ifdef SCM_RIGHTS
     
154.                 union fdmsg  cmsg;
     
155.                 struct cmsghdr* h;
     
156. 
     
157.                 msg.msg_control = cmsg.buf;
     
158.                 msg.msg_controllen = sizeof(union fdmsg);
     
159.                 msg.msg_flags = 0;
     
160. 
     
161.                 h = CMSG_FIRSTHDR(&msg);
     
162.                 h->cmsg_len   = CMSG_LEN(sizeof(int));
     
163.                 h->cmsg_level = SOL_SOCKET;  /* Linux does not set these */
     
164.                 h->cmsg_type  = SCM_RIGHTS;  /* upon return */
     
165.                 *((int*)CMSG_DATA(h)) = -1;
     
166. 
     
167.                 if ((count = recvmsg(sock_fd, &msg, 0)) < 0) {
     
168.                         ret = 0;
     
169.                 } else {
     
170.                         h = CMSG_FIRSTHDR(&msg);   /* can realloc? */
     
171.                         if (   h == NULL
     
172.                             || h->cmsg_len    != CMSG_LEN(sizeof(int))
     
173.                             || h->cmsg_level  != SOL_SOCKET
     
174.                             || h->cmsg_type   != SCM_RIGHTS ) {
     
175.                                 /* This should really never happen */
     
176.                                 if (h)
     
177.                                   fprintf(stderr,
     
178.                                     "%s:%d: protocol failure: %d %d %d\n",
     
179.                                     __FILE__, __LINE__,
     
180.                                     h->cmsg_len,
     
181.                                     h->cmsg_level, h->cmsg_type);
     
182.                                 else
     
183.                                   fprintf(stderr,
     
184.                                     "%s:%d: protocol failure: NULL cmsghdr*\n",
     
185.                                     __FILE__, __LINE__);
     
186.                                 ret = 0;
     
187.                         } else {
     
188.                                 ret = *((int*)CMSG_DATA(h));
     
189.                                 /*fprintf(stderr, "recv ok %d\n", ret);*/
     
190.                         }
     
191.                 }
     
192. #else
     
193.                 int receive_fd;
     
194.                 msg.msg_accrights = &receive_fd;
     
195.                 msg.msg_accrightslen = sizeof(receive_fd);
     
196. 
     
197.                 if (recvmsg(sock_fd, &msg, 0) < 0) {
     
198.                         panic("recvmsg");
     
199.                         ret = 0;
     
200.                 } else {
     
201.                         ret = receive_fd;
     
202.                 }
     
203. #endif
     
204.         }
     
205. 
     
206.         return ret;
     
207. }
     
208. 
     
209. int main(int argc, char *argv[])
     
210. {
     
211.         int fd, err, new_fd;
     
212.         int sockpair[2];
     
213.         char buf[1024];
     
214. 
     
215.         fd = open(argv[1], O_RDWR);
     
216.         if (fd < 0)
     
217.                 panic("open");
     
218. 
     
219.         err = socketpair(PF_LOCAL, SOCK_DGRAM, 0, sockpair);
     
220.         if (err)
     
221.                 panic("socketpair");
     
222. 
     
223.         if (!sendfd(sockpair[0], fd))
     
224.                 panic("sendfd");
     
225. 
     
226.         close(fd);
     
227. 
     
228.         err = revokeat(AT_FDCWD, argv[1]);
     
229.         if (err)
     
230.                 panic("revokeat");
     
231. 
     
232.         new_fd = recvfd(sockpair[1]);
     
233.         if (new_fd <= 0)
     
234.                 panic("recvfd");
     
235. 
     
236.         if (read(new_fd, buf, 1024) != -1 || errno != EBADF) {
     
237.                 printf("Failed: can read from SCM_RIGHTS descriptor\n");
     
238.                 exit(1);
     
239.         }
     
240. 
     
241.         printf("Test OK.\n");
     
242.         return 0;
     
243. }
     
244. 
     

复制代码

thomas_ar

Current Unix systems provide a way to pass any open descriptor from one process to any other process. That is, there is no need for the processes to be related, such as a parent and its child. The technique requires us to first establish a Unix domain socket between the two processes and then use sendmsg to send a special message across the Unix domain socket. This message is handled specially by the kernel, passing the open descriptor from the sender to the receiver.

yaoaiguo

这个是可以实现的，我以前做过一个类似的。
主进程先fork()很多子进程，然后accept之后把套接字传递给子进程，让子进程和客户端通讯。自己继续监听。
麻烦的地方是，系统繁忙时候处理起来很麻烦。

思一克

传递SOCKFD的过程也是有代价的. 至少使程序看起来多了不少麻烦.

原帖由 yaoaiguo 于 2009-3-13 15:56 发表
这个是可以实现的，我以前做过一个类似的。
主进程先fork()很多子进程，然后accept之后把套接字传递给子进程，让子进程和客户端通讯。自己继续监听。
麻烦的地方是，系统繁忙时候处理起来很麻烦。

zhoubug

step 1: parent.fork() 子进程池
step 2: parent.listen()
step 3: then all childs run accept() and 处理连接 （识操作系统支持情况是否需要自己同步）
         parent维护子进程存活

上面也是apache prefork 方式的处理方式 并不是上面有兄弟理解的需要考虑怎么传送fd
我想搂主的老师是不是比较熟悉apache源码

wcw

我昨天实现了一个进程池
http://blog.chinaunix.net/u1/37472/showart_1862390.html
不过还是没有使用到“文件描述符传递”，因为我让子进程自己去accept，而不是父进程accept后把connfd传给子进程。不过“文件描述符传递”的使用我还要继续学习下，虽然这里没用到，但我觉得这东西在以后的工作中会很有用。

代码写得很丑，各位轻拍。

tonghuasanren

用pipe()管道啊
父进程给子进程传数据