epoll编程实例

#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 <stdlib.h>
#include <string.h>
#include <pthread.h>

#define MAXLINE 1024
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT 5555
#define INFTIM 1000

//线程池任务队列结构体
struct task{
    int fd;            //需要读写的文件描述符

    struct task *next; //下一个任务
};

//用于保存向客户端发送一次消息所需的相关数据
struct user_da

ta{
    int fd;

    unsigned int n_size;

    char line[MAXLINE];
};
 
//线程的任务函数
void * readtask(void *args);

void * writetask(void *args);

//声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
struct epoll_event ev,events[20];

int epfd;

pthread_mutex_t mutex;

pthread_cond_t cond1;

struct task *readhead=NULL,*readtail=NULL,*writehead=NULL;

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,nfds;

    pthread_t tid1,tid2;

    struct task *new_task = NULL;

    struct user_data *rdata = NULL;

    socklen_t clilen;

    pthread_mutex_init(&mutex, NULL);

    pthread_cond_init(&cond1, NULL);

    //初始化用于读线程池的线程，开启两个线程来完成任务，两个线程会互斥地访问任务链表
    pthread_create(&tid1, NULL, readtask, NULL);

    pthread_create(&tid2, NULL, readtask, NULL);

    //生成用于处理accept的epoll专用的文件描述符   
    epfd = epoll_create(256);

    struct sockaddr_in clientaddr;

    struct sockaddr_in serveraddr;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    //把socket设置为非阻塞方式
    setnonblocking(listenfd);

    //设置与要处理的事件相关的文件描述符
    ev.data.fd = listenfd;

    //设置要处理的事件类型，当描述符可读时出发，出发方式为ET模式
    ev.events = EPOLLIN | EPOLLET;

    //注册epoll事件
    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

    bzero(&serveraddr, sizeof(serveraddr));

    serveraddr.sin_family = AF_INET;

    const char *local_addr = "127.0.0.1";

    inet_aton(local_addr, &(serveraddr.sin_addr)); //htons(SERV_PORT);

    serveraddr.sin_port=htons(SERV_PORT);

    bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));

    //开始监听
    listen(listenfd, LISTENQ);

    maxi = 0;

     for ( ; ; ) {

          //等待epoll事件的发生
          nfds=epoll_wait(epfd, events, 20, 500);

          //处理所发生的所有事件     
        for(i=0; i < nfds; ++i)
        {

        if(events[i].data.fd==listenfd)
        {
            connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);

            if(connfd<0){
                perror("connfd<0");

                exit(1);
            }

            setnonblocking(connfd);

            const char *str = inet_ntoa(clientaddr.sin_addr);

            std::cout<<"connec_ from >> " << str << std::endl;

            //设置用于读操作的文件描述符
            ev.data.fd=connfd;

            //设置用于注测的读操作事件
            ev.events=EPOLLIN | EPOLLET;

            //注册ev
            epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
        }
        else if(events[i].events & EPOLLIN)
        {
            printf("reading!/n");                

            if ( (sockfd = events[i].data.fd) < 0) continue;

            new_task = new task();

            new_task->fd =sockfd;

            new_task->next = NULL;

            //添加新的读任务
            pthread_mutex_lock(&mutex);

            if(readhead == NULL)
            {
                readhead = new_task;

                readtail = new_task;
            }   
            else
            {   
                readtail->next = new_task;

                readtail = new_task;
            }   

            //唤醒所有等待cond1条件的线程
            pthread_cond_broadcast(&cond1);

            pthread_mutex_unlock(&mutex);  
        }
        else if(events[i].events & EPOLLOUT)
        {   
            rdata=(struct user_data *)events[i].data.ptr;

             sockfd = rdata->fd;

             write(sockfd, rdata->line, rdata->n_size);

             delete rdata;

             //设置用于读操作的文件描述符
             ev.data.fd=sockfd;

             //设置用于注测的读操作事件
            ev.events=EPOLLIN | EPOLLET;

             //修改sockfd上要处理的事件为EPOLIN
            epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
        }
          }
     }
}

void * readtask(void *args)
{
    int fd=-1;

    unsigned int n;

    //用于把读出来的数据传递出去
    struct user_data *data = NULL;

    while(1){

        //互斥访问任务队列
        pthread_mutex_lock(&mutex);

        //等待到任务队列不为空
        while(readhead == NULL)
             pthread_cond_wait(&cond1, &mutex); //线程阻塞，释放互斥锁，当等待的条件等到满足时，它会再次获得互斥锁

        fd = readhead->fd;

        //从任务队列取出一个读任务
        struct task *tmp = readhead;

        readhead = readhead->next;

        delete tmp;

        pthread_mutex_unlock(&mutex);

        data = new user_data();

        data->fd=fd;

        if ( (n = read(fd, data->line, MAXLINE)) < 0) {
            if (errno == ECONNRESET)
                close(fd);
            else
                std::cout<<"readline error"<< std::endl;

            if(data != NULL) delete data;
        } else if (n == 0) {
        //客户端关闭了，其对应的连接套接字可能也被标记为EPOLLIN，然后服务器去读这个套接字
        //结果发现读出来的内容为0，就知道客户端关闭了。
            close(fd);

           printf("Client close connect!/n");

           if(data != NULL) delete data;

        } else{

        std::cout << "read from client: " << data->line << std::endl;

        data->n_size = n;

        //设置需要传递出去的数据
        ev.data.ptr = data;

        //设置用于注测的写操作事件
        ev.events = EPOLLOUT | EPOLLET;

        //修改sockfd上要处理的事件为EPOLLOUT
        epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
           }
    }
}

=========================================================
给出一个简单的客户端吧，从《Linux编程技术详解》书中拷贝而来。
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netdb.h>
#include <unistd.h>

int main(int argc,char *argv[])
{
    int connect_fd;
    int ret;
    char snd_buf[1024];
    int i;
    int port;
    int len;

    static struct sockaddr_in srv_addr;

    if(argc!=3){
        printf("Usage: %s server_ip_address port/n",argv[0]);
        return 1;
    }   

    port=atoi(argv[2]);

    connect_fd=socket(PF_INET,SOCK_STREAM,0);
    if(connect_fd<0){
        perror("cannot create communication socket");
        return 1;
    }   

    memset(&srv_addr,0,sizeof(srv_addr));
    srv_addr.sin_family=AF_INET;
    srv_addr.sin_addr.s_addr=inet_addr(argv[1]);
    srv_addr.sin_port=htons(port);

    ret=connect(connect_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr));
    if(ret==-1){
        perror("cannot connect to the server");
        close(connect_fd);
        return 1;
    }
   
    memset(snd_buf,0,1024);

    while(1){
        write(STDOUT_FILENO,"input message:",14);

        bzero(snd_buf, 1024);
       
        len=read(STDIN_FILENO,snd_buf,1024);

        if(snd_buf[0]=='@')
            break;

        if(len>0)
            write(connect_fd,snd_buf,len);

        len=read(connect_fd,snd_buf,len);
        if(len>0)
            printf("Message from server: %s/n",snd_buf);
    }
   
    close(connect_fd);
    return 0;
}

===========================================
ecy@ecy-geek:~/C$ ./epoll_server
connec_ from >> 127.0.0.1
reading!
read from client: ni hao ya ya ya ya ya

reading!
read from client: hello world

reading!
Client close connect!

ecy@ecy-geek:~/C$ pstree | grep epoll
     |-gnome-terminal-+-bash---epoll_server---2*[{epoll_server}]

ecy@ecy-geek:~/C$ ./p13.5 127.0.0.1 5555
input message:ni hao ya ya ya ya ya
Message from server: ni hao ya ya ya ya ya

input message:hello world
Message from server: hello world

input message:@