多进程服务器中,epoll的创建应该在创建子进程之后
看我的测试代码,似乎应该是在创建子进程之后创建epoll的fd,否则程序将会有问题,试将代码中两个CreateWorker函数的调用位置分别调用,一个在创建epoll fd之前,一个在之后,在调用在创建之前的代码会出问题,在我的机器上(linux内核2.6.26)表现的症状就是所有进程的epoll_wait函数返回0, 而客户端似乎被阻塞了:
服务器端:
测试客户端:
我查看了lighttpd的实现,也是在创建完子进程之后才创建的epoll的fd.
请问谁知道哪里有讲解这个的文档?
这是美丽的分割线:
-----------------------------------------------------------------------
感谢luke, 他帮我解释了这个问题的原因:
假如fd1是由A进程加入epfd的，而且用的是ET模式，那么加入通知的是进程B，显然B进程不会对fd1进行处理，所以以后fd1的事件再不会通知，所以 经过几次循环之后，所有的fd都没有事件通知了，所以epoll_wait在timeout之后就返回0了。而在客户端的结果可想而知，只能是被阻塞。
也就是说, 这是一种发生在epoll fd上面的类似于"惊群"的现象.
服务器端:
#include <iostream>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/ in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;
#define MAXLINE 5
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT 5000
#define INFTIM 1000
typedef struct task_t
{
int fd;
char buffer[100];
int n;
}task_t;
int CreateWorker( int nWorker)
{
if (0 < nWorker)
{
bool bIsChild;
pid_t nPid;
while (!bIsChild)
{
if (0 < nWorker)
{
nPid = ::fork();
if (nPid > 0)
{
bIsChild = false;
--nWorker;
}
else if (0 == nPid)
{
bIsChild = true;
printf("create worker %d success!\n", ::getpid());
}
else
{
printf("fork error: %s\n", ::strerror(errno));
return -1;
}
}
else
{
int nStatus;
if (-1 == ::wait(&nStatus))
{
++nWorker;
}
}
}
}
return 0;
}
void setnonblocking( int sock)
{
int opts;
opts=fcntl(sock,F_GETFL);
if(opts<0)
{
perror("fcntl(sock,GETFL)");
exit(1);
}
opts = opts|O_NONBLOCK;
if(fcntl(sock,F_SETFL,opts)<0)
{
perror("fcntl(sock,SETFL,opts)");
exit(1);
}
}
int main()
{
int i, maxi, listenfd, connfd, sockfd,epfd,nfds;
ssize_t n;
char line[MAXLINE];
socklen_t clilen;
struct epoll_event ev,events[20];
struct sockaddr_in clientaddr;
struct sockaddr_in serveraddr;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
char *local_addr="127.0.0.1";
inet_aton(local_addr,&(serveraddr.sin_addr)); // htons(SERV_PORT);
serveraddr.sin_port=htons(SERV_PORT);
// 地址重用
int nOptVal = 1;
socklen_t nOptLen = sizeof( int);
if (-1 == ::setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &nOptVal, nOptLen))
{
return -1;
}
setnonblocking(listenfd);
bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
listen(listenfd, LISTENQ);
CreateWorker(5);
// 把socket设置为非阻塞方式
// 生成用于处理accept的epoll专用的文件描述符
epfd=epoll_create(256);
// 设置与要处理的事件相关的文件描述符
ev.data.fd=listenfd;
// 设置要处理的事件类型
ev.events=EPOLLIN|EPOLLET;
// ev.events=EPOLLIN;
// 注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
// CreateWorker(5);
maxi = 0;
task_t task;
task_t *ptask;
while( true)
{
// 等待epoll事件的发生
nfds=epoll_wait(epfd,events,20,500);
// 处理所发生的所有事件
for(i=0;i<nfds;++i)
{
if(events[i].data.fd==listenfd)
{
connfd = accept(listenfd,NULL, NULL);
if(connfd<0){
printf("connfd<0, listenfd = %d\n", listenfd);
printf("error = %s\n", strerror(errno));
exit(1);
}
setnonblocking(connfd);
// 设置用于读操作的文件描述符
memset(&task, 0, sizeof(task));
task.fd = connfd;
ev.data.ptr = &task;
// 设置用于注册的读操作事件
ev.events=EPOLLIN|EPOLLET;
// ev.events=EPOLLIN;
// 注册ev
epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
}
else if(events[i].events&EPOLLIN)
{
cout << "EPOLLIN" << endl;
ptask = (task_t*)events[i].data.ptr;
sockfd = ptask->fd;
if ( (ptask->n = read(sockfd, ptask->buffer, 100)) < 0) {
if (errno == ECONNRESET) {
close(sockfd);
events[i].data.ptr = NULL;
} else
std::cout<<"readline error"<<std::endl;
} else if (ptask->n == 0) {
close(sockfd);
events[i].data.ptr = NULL;
}
ptask->buffer[ptask->n] = '\0';
cout << "read " << ptask->buffer << endl;
// 设置用于写操作的文件描述符
ev.data.ptr = ptask;
// 设置用于注测的写操作事件
ev.events=EPOLLOUT|EPOLLET;
// 修改sockfd上要处理的事件为EPOLLOUT
epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
}
else if(events[i].events&EPOLLOUT)
{
cout << "EPOLLOUT" << endl;
ptask = (task_t*)events[i].data.ptr;
sockfd = ptask->fd;
write(sockfd, ptask->buffer, ptask->n);
// 设置用于读操作的文件描述符
ev.data.ptr = ptask;
// 修改sockfd上要处理的事件为EPOLIN
epoll_ctl(epfd,EPOLL_CTL_DEL,sockfd,&ev);
cout << "write " << ptask->buffer;
memset(ptask, 0, sizeof(*ptask));
close(sockfd);
}
}
}
return 0;
}
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/ in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;
#define MAXLINE 5
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT 5000
#define INFTIM 1000
typedef struct task_t
{
int fd;
char buffer[100];
int n;
}task_t;
int CreateWorker( int nWorker)
{
if (0 < nWorker)
{
bool bIsChild;
pid_t nPid;
while (!bIsChild)
{
if (0 < nWorker)
{
nPid = ::fork();
if (nPid > 0)
{
bIsChild = false;
--nWorker;
}
else if (0 == nPid)
{
bIsChild = true;
printf("create worker %d success!\n", ::getpid());
}
else
{
printf("fork error: %s\n", ::strerror(errno));
return -1;
}
}
else
{
int nStatus;
if (-1 == ::wait(&nStatus))
{
++nWorker;
}
}
}
}
return 0;
}
void setnonblocking( int sock)
{
int opts;
opts=fcntl(sock,F_GETFL);
if(opts<0)
{
perror("fcntl(sock,GETFL)");
exit(1);
}
opts = opts|O_NONBLOCK;
if(fcntl(sock,F_SETFL,opts)<0)
{
perror("fcntl(sock,SETFL,opts)");
exit(1);
}
}
int main()
{
int i, maxi, listenfd, connfd, sockfd,epfd,nfds;
ssize_t n;
char line[MAXLINE];
socklen_t clilen;
struct epoll_event ev,events[20];
struct sockaddr_in clientaddr;
struct sockaddr_in serveraddr;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
char *local_addr="127.0.0.1";
inet_aton(local_addr,&(serveraddr.sin_addr)); // htons(SERV_PORT);
serveraddr.sin_port=htons(SERV_PORT);
// 地址重用
int nOptVal = 1;
socklen_t nOptLen = sizeof( int);
if (-1 == ::setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &nOptVal, nOptLen))
{
return -1;
}
setnonblocking(listenfd);
bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
listen(listenfd, LISTENQ);
CreateWorker(5);
// 把socket设置为非阻塞方式
// 生成用于处理accept的epoll专用的文件描述符
epfd=epoll_create(256);
// 设置与要处理的事件相关的文件描述符
ev.data.fd=listenfd;
// 设置要处理的事件类型
ev.events=EPOLLIN|EPOLLET;
// ev.events=EPOLLIN;
// 注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
// CreateWorker(5);
maxi = 0;
task_t task;
task_t *ptask;
while( true)
{
// 等待epoll事件的发生
nfds=epoll_wait(epfd,events,20,500);
// 处理所发生的所有事件
for(i=0;i<nfds;++i)
{
if(events[i].data.fd==listenfd)
{
connfd = accept(listenfd,NULL, NULL);
if(connfd<0){
printf("connfd<0, listenfd = %d\n", listenfd);
printf("error = %s\n", strerror(errno));
exit(1);
}
setnonblocking(connfd);
// 设置用于读操作的文件描述符
memset(&task, 0, sizeof(task));
task.fd = connfd;
ev.data.ptr = &task;
// 设置用于注册的读操作事件
ev.events=EPOLLIN|EPOLLET;
// ev.events=EPOLLIN;
// 注册ev
epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
}
else if(events[i].events&EPOLLIN)
{
cout << "EPOLLIN" << endl;
ptask = (task_t*)events[i].data.ptr;
sockfd = ptask->fd;
if ( (ptask->n = read(sockfd, ptask->buffer, 100)) < 0) {
if (errno == ECONNRESET) {
close(sockfd);
events[i].data.ptr = NULL;
} else
std::cout<<"readline error"<<std::endl;
} else if (ptask->n == 0) {
close(sockfd);
events[i].data.ptr = NULL;
}
ptask->buffer[ptask->n] = '\0';
cout << "read " << ptask->buffer << endl;
// 设置用于写操作的文件描述符
ev.data.ptr = ptask;
// 设置用于注测的写操作事件
ev.events=EPOLLOUT|EPOLLET;
// 修改sockfd上要处理的事件为EPOLLOUT
epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
}
else if(events[i].events&EPOLLOUT)
{
cout << "EPOLLOUT" << endl;
ptask = (task_t*)events[i].data.ptr;
sockfd = ptask->fd;
write(sockfd, ptask->buffer, ptask->n);
// 设置用于读操作的文件描述符
ev.data.ptr = ptask;
// 修改sockfd上要处理的事件为EPOLIN
epoll_ctl(epfd,EPOLL_CTL_DEL,sockfd,&ev);
cout << "write " << ptask->buffer;
memset(ptask, 0, sizeof(*ptask));
close(sockfd);
}
}
}
return 0;
}
测试客户端:
#!/usr/bin/perl
use strict;
use Socket;
use IO::Handle;
sub echoclient
{
my $host = "127.0.0.1";
my $port = 5000;
my $protocol = getprotobyname("TCP");
$host = inet_aton($host);
socket(SOCK, AF_INET, SOCK_STREAM, $protocol) or die "socket() failed: $!";
my $dest_addr = sockaddr_in($port, $host);
connect(SOCK, $dest_addr) or die "connect() failed: $!";
SOCK->autoflush(1);
my $msg_out = "hello world\n";
print "out = ", $msg_out;
print SOCK $msg_out;
my $msg_in = <SOCK>;
print "in = ", $msg_in;
close SOCK;
}
#&echoclient;
#exit(0);
for (my $i = 0; $i < 9999; $i++)
{
echoclient;
}
use strict;
use Socket;
use IO::Handle;
sub echoclient
{
my $host = "127.0.0.1";
my $port = 5000;
my $protocol = getprotobyname("TCP");
$host = inet_aton($host);
socket(SOCK, AF_INET, SOCK_STREAM, $protocol) or die "socket() failed: $!";
my $dest_addr = sockaddr_in($port, $host);
connect(SOCK, $dest_addr) or die "connect() failed: $!";
SOCK->autoflush(1);
my $msg_out = "hello world\n";
print "out = ", $msg_out;
print SOCK $msg_out;
my $msg_in = <SOCK>;
print "in = ", $msg_in;
close SOCK;
}
#&echoclient;
#exit(0);
for (my $i = 0; $i < 9999; $i++)
{
echoclient;
}
我查看了lighttpd的实现,也是在创建完子进程之后才创建的epoll的fd.
请问谁知道哪里有讲解这个的文档?
这是美丽的分割线:
-----------------------------------------------------------------------
感谢luke, 他帮我解释了这个问题的原因:
假如fd1是由A进程加入epfd的，而且用的是ET模式，那么加入通知的是进程B，显然B进程不会对fd1进行处理，所以以后fd1的事件再不会通知，所以 经过几次循环之后，所有的fd都没有事件通知了，所以epoll_wait在timeout之后就返回0了。而在客户端的结果可想而知，只能是被阻塞。
也就是说, 这是一种发生在epoll fd上面的类似于"惊群"的现象.
posted on 2008-10-08 22:52 那谁 阅读(10943) 评论(18) 编辑 收藏 引用 所属分类: 网络编程 、服务器设计
评论
# re: 多进程服务器中,epoll的创建应该在创建子进程之后[未登录] 回复 更多评论
想法不错，把accept前的多进程用于多路复用函数，完美的方案，呵呵。现实世界往往都不是那么完美。
还没看到过select poll epoll类的应用前面可以加fork做这种领导者模型的。想想也不太现实，即使可以多进程select，那么一个被唤醒后，读数据前，另一个也一定会被唤醒，这样还是和单进程一样。
# re: 多进程服务器中,epoll的创建应该在创建子进程之后[未登录] 回复 更多评论
@cppexplore没看懂...什么叫"把accept前的多进程用于多路复用函数"..
# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
如果在创建worker之前就创建了epoll fd, 那么这个fd会被5个进程所共享，因为fork会复制所有父进程的内容；如果是之后创建，等于是每个进程都会创建一个自己的epoll fd。那么这两者之间有什么差别呢？# re: 多进程服务器中,epoll的创建应该在创建子进程之后[未登录] 回复 更多评论
@创listen后 accept前加fork是常见的设计，在不使用多路复用函数的情况下
@luke
区别就是fork前生成fd ，会导致多个进程在相同epoll上wait
# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
汗一个，这不是cu的converse嘛。。# re: 多进程服务器中,epoll的创建应该在创建子进程之后[未登录] 回复 更多评论
@Ask u是我
# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
这里有个问题，我想值得思考：如果多个进程同时去epoll_wait同一个epfd，那么加入有fd状态发生了变化，内核怎么知道去通知哪一个进程来处理呢？我想在内核的实现上，不会去把每个监听的fd和进程进行绑定。所以内核不知道该去通知哪个进程来处理这些状态发生变化的fd们，所以出现了上述的情况，我没有读过epoll_wait的实现代码，上述判断只属于猜测。
在google上也看到过有人评论，当多个线程监听同一个epfd的时候，会发现所有线程同时从epoll_wait出来，我想这也是因为epoll_wait内部不知道该通知哪个线程来处理所导致的。
# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
再进一步解释：epoll_wait还是要工作的，即使是在多个进程同时wait在同一个epfd上，那会怎么工作呢，很显然，按epoll_wait顺序来通知进程。
加入 fd1是由A进程加入epfd的，而且用的是ET模式，那么加入通知的是进程B，显然B进程不会对fd1进行处理，所以以后fd1的事件再不会通知，所以经过几次循环之后，所有的fd都没有事件通知了，所以epoll_wait在timeout之后就返回0了。而在客户端的结果可想而知，只能是被阻塞。
# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
这里还有一个问题需要讨论一下：你在加listenfd的时候，用的是ET模式。ET模式的情况是，如果你不一次把缓冲区读空，以后，epoll就不会再通知你有数据。所以在大量并发连接的情况下，你只accept一次之后，会不会在buf中同时还有另外一个connect。这样的话，会不会以后就得不到listenfd的事件通知了？只是怀疑，没有实践过，见谅。
# re: 多进程服务器中,epoll的创建应该在创建子进程之后[未登录] 回复 更多评论
@luke感谢你给我的解答,这个问题我已经弄明白了.
另外,accept的问题确实存在,同样感谢你提醒了我.
# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
请教一下。是不是当有连接事件发生时，内核只通知某一个进程中epoll_wait上有事件发生？而这种连接负载均衡是由内核实现的，在我们的程序中不用管？# re: 多进程服务器中,epoll的创建应该在创建子进程之后[未登录] 回复 更多评论
@firefly是的.
# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
撇开你说的这个问题不谈，你的程序中对所有的socket的处理，怎么只用到了一个task变量？其他第二个socket可能冲掉第一个socket。# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
还有代码里if (-1 == ::wait(&nStatus))应该是if (-1 ！= ::wait(&nStatus))吧？# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
accept后的处理部分有大问题：如果有另外一个客户再连接上来就会清洗掉原来task中的内部。。无法做到多用户并发！# re: 多进程服务器中,epoll的创建应该在创建子进程之后[未登录] 回复 更多评论
listenfd被加入到所有的进程的epoll中，当listenfd可读的时候，根据epoll_wait的惊群现象，是不是所有的子进程都会被唤醒？这样这种多进程结构会不会有性能问题。# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
我测试后发现不是这样的。加入 fd1是由A进程加入epfd的，而且用的是ET模式，那么加入通知的是进程B，显然B进程不会对fd1进行处理，所以以后fd1的事件再不会通知，所以经过几次循环之后，所有的fd都没有事件通知了，所以epoll_wait在timeout之后就返回0了。而在客户端的结果可想而知，只能是被阻塞。
每次都是获得的fd是4的时候阻塞，即从epoll_wait返回的fd是epfd的时候阻塞了。我不知道原因是什么
# re: 多进程服务器中,epoll的创建应该在创建子进程之后 回复 更多评论
lz没有close epollfd