我们希望一个socket只能同时被一个线程(进程)操作。epoll的EPOLLONESHOT可以实现。
对于注册了EPOLLONESHOT事件的文件描述符,操作系统最多触发其上注册的一个可读、可写或者异常事件,且只触发一次。 除非我们使用epoll_ctl函数重置该文件描述符上注册的EPOLLONESHOT事件。这样,当一个线程在处理某个socket时候,其他线程是不可能有机会操作该socket的。反过来,注册了EPOLLONESHOT事件的socket一旦被某个线程处理完毕,该线程就应该立即重置这个socket上的EPOLLONESHOT事件,以确保这个socket下一次可读时,其EPOLLIN事件能被触发,进而让其他工作线程有机会继续处理这个socket。
下面的代码演示了EPOLLONESHOT的使用
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 1024
struct fds{
int epollfd;
int sockfd;
};
// 将文件描述符设置成非阻塞
int setNonBlocking(int fd){
int old_opt = fcntl(fd, F_GETFD);
int new_opt = old_opt | O_NONBLOCK;
fcntl(fd, F_SETFD,new_opt);
return old_opt;
}
/**
将文件描述符fd上的EPOLLIN注册到epollfd指示的epoll内核事件中,参数oneshot指定是否注册fd上的EPOLLONESHOT事件
*/
void addfd(int epollfd, int fd,bool oneshot){
epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN | EPOLLET;
if (oneshot) {
event.events |= EPOLLONESHOT;
}
epoll_ctl(epollfd, EPOLL_CTL_ADD,fd, &event);
setNonBlocking(fd);
}
/**
重置fd上的事件。这样操作之后,尽管fd上的EPOLLONESHOT事件被注册,但是操作仍然会触发fd上的EPOLLIN事件,且只能触发一次
*/
void reset_oneshot(int epoll_fd,int fd){
epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event);
}
/**
工作线程
*/
void* worker(void* arg){
int sockfd = ((fds*)arg)->sockfd;
int epollfd = ((fds*)arg)->epollfd;
printf("start new thread to reveive data on fd : %d\n",sockfd);
char buf[BUFFER_SIZE];
memset(buf, '\0', BUFFER_SIZE);
/**
循环读取sockfd上的数据,直到遇到EAGAIN错误
*/
while (1) {
int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
if(ret == 0){
close(sockfd);
printf("foreiner closed the connection\n");
break;
}else if(ret < 0){
if (errno == EAGAIN) {
reset_oneshot(epollfd, sockfd);
printf("read later\n");
break;
}
}else{
printf("get content : %s\n",buf);
sleep(5);
}
}
printf("end thread receiveing data on fd : %d\n",sockfd);
}
int main(int argc, const char * argv[]) {
if (argc <= 2) {
printf("usage: %s ip_address port_number\n", basename(argv[0]));
return 1;
}
const char* ip = argv[1];
int port = atoi(argv[2]);
int ret = 0;
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET, ip, &address.sin_addr);
address.sin_port = htons(port);
int socket_fd = socket(PF_INET, SOCK_STREAM, 0);
if ( socket_fd == -1 ){
perror("create socket error");
exit(1);
}
ret = bind(socket_fd, (struct sockaddr*)& address, sizeof(address));
if(ret == -1 ) {
perror("bind error");
exit(1);
}
ret = listen(socket_fd, 5);
if ( ret == -1 ){
perror("listen error");
exit(1);
}
epoll_event events[MAX_EVENT_NUMBER];
int epollfd = epoll_create(5);
if (epollfd == -1) {
perror("epoll create error");
exit(1);
}
/**
监听socket 的fd不能注册EPOLLONESHOT事件的,否则应用程序只能处理一个客户连接!因为后续的客户连接请求将不再触发socket_fd上的EPOLLIN
*/
addfd(epollfd, socket_fd, false);
while (1) {
int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
if(ret < 0){
printf("epoll failure\n");
break;
}
for(int i = 0;i < ret;i++){
int sockfd = events[i].data.fd;
if (sockfd == socket_fd) {
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof(client_address);
int connfd = accept(socket_fd, (struct sockaddr*)&client_address, &client_addrlength);
//对每个非监听文件描述符都注册EPOLLONESHOT事件
addfd(epollfd, connfd, true);
}else if(events[i].events & EPOLLIN){
pthread_t thread;
fds fds_for_new_worker;
fds_for_new_worker.epollfd = epollfd;
fds_for_new_worker.sockfd = sockfd;
//新启动一个工作线程为sockfd服务
pthread_create(&thread, NULL, worker, (void*) &fds_for_new_worker);
}else{
printf("something else happened \n");
}
}
}
close(socket_fd);
return 0;
}
上述程序在主线程用于监听连接,当有新的连接时,监听socket的文件描述有事件发生,epoll_wait返回了包含该事件的数量,从就绪事件列表中读取该文件描述符,用accept接受该连接,并将该连接的文件描述符放入事件列表中,在连接事件中,若有可读事件发生,开启新的线程去接收客户端发送来的消息。对于每个非监听文件描述符都注册EPOLLONESHOT事件,以保证操作系统最多触发文件描述符上的一个可读、可写或者异常事件,且只触发一次。但是一旦事件被处理完成,该线程就应该立即重置这个socket上的EPOLLONTSHOT事件,以确保这个socket下一次的事件能被触发,进而让其他线程继续处理这个事件。