服务器编程——I/O复用（select、poll、epoll）

最新推荐文章于 2022-07-11 07:37:00 发布
最新推荐文章于 2022-07-11 07:37:00 发布
阅读量887 收藏
点赞数
分类专栏： Linux技术 服务器编程 文章标签： 服务器编程 IO复用 select poll epoll
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Linux_ever/article/details/50731811
版权








select例子：

服务器上用select来监听connfd是否就绪,如果是正常数据的话，则正常处理。如果是异常数据的话，则异常处理。

服务器端代码：

/*************************************************************************
	> File Name: practice_91.c
	> Author: 
	> Mail: 
	> Created Time: 2016年02月24日 星期三 15时38分01秒
 ************************************************************************/
/*
能够同时接收普通数据和带外数据
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>


int main(int argc, char *argv[])
{
    if(argc <= 2){
        printf("%s ip_address port_number\n", 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);
    
    //socket
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if(listenfd < 0){
        printf("socket error\n");
        return -1;
    }

    //bind
    ret = bind(listenfd, (struct sockaddr *)&address, sizeof(address));
    if(ret != 0){
        printf("bind error\n");
        return -1;
    }

    //listen
    ret = listen(listenfd, 5);
    if(ret != 0){
        printf("listen error\n");
        return -1;
    }

    //客户端地址
    struct sockaddr_in client_addr;
    socklen_t client_addrlen = sizeof(client_addr);
    
    //accept
    int connfd = accept(listenfd, (struct sockaddr *)&client_addr, &client_addrlen);
    if(connfd < 0){
        printf("accept error\n");
        close(listenfd);
        return -1;
    }

    char buf[1024];
    fd_set read_fds;
    fd_set exception_fds;
    FD_ZERO(&read_fds);
    FD_ZERO(&exception_fds);
    
    while(1){
        memset(buf, 0, sizeof(buf));
        FD_SET(connfd, &read_fds);
        FD_SET(connfd, &exception_fds);
    
        ret = select(connfd+1, &read_fds, NULL, &exception_fds, NULL);//会一直阻塞，直到文件描述符就绪;每次事件发生之后，都要再重新设置文件描述符
        if(ret < 0){
            printf("select error\n");
            break;
        }

        if(FD_ISSET(connfd, &read_fds)){//正常可读事件
            ret = recv(connfd, buf, sizeof(buf)-1, 0);
            if(ret <= 0){//ret == 0表示对方关闭了连接
                break;
            }
            printf("get %d bytes of normal data: %s\n", ret, buf);
        }
        else if(FD_ISSET(connfd, &exception_fds)){//对于异常事件
            ret = recv(connfd, buf, sizeof(buf)-1, MSG_OOB);
            if(ret <= 0){//ret == 0表示对方关闭了连接
                break;
            }
            printf("get %d bytes of oob data: %s\n", ret, buf);
        }
    }
    
    close(connfd);
    close(listenfd);

    return 0;
}

客户端代码：

/*************************************************************************
	> File Name: 53backlog.c
	> Author: 
	> Mail: 
	> Created Time: 2016年01月16日 星期六 11时35分15秒
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <string.h>
#include <assert.h>
#include <stdbool.h>//包含bool类型，C语言是没有bool类型的，C++才有
#include <unistd.h>
#include <errno.h>

static bool stop = false;

static void handle_term(int sig)
{
    stop = true;
}

int main(int argc, char *argv[])
{
    signal(SIGTERM, handle_term);
    if(argc <= 2){
        printf("usage: %s ip_address port_number backlog\n", argv[0]);
        return 1;
    }

    const char * ip = argv[1];
    int port = atoi(argv[2]);
    int backlog = 5;//atoi(argv[3]);

    int sock = socket(AF_INET, SOCK_STREAM, 0);
    assert(sock >= 0);

    //创建ipv4的地址
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    address.sin_port = htons(port);
    inet_pton(AF_INET, ip, (void *)&address.sin_addr);

    int ret = connect(sock, (struct sockaddr *)&address, sizeof(address));
    if(ret < 0)
        printf("connect failed.\n");
    else{
        const char * oob_data = "abc";
        const char * normal_data = "123";

        printf("send the normal_data: %s\n", normal_data);
        send(sock, normal_data, strlen(normal_data), 0);

        sleep(1);//发送延迟1秒，如果没有延迟的话，太快有时候会导致收不到oob_data
        printf("send the oob_data: %s\n", oob_data);
        send(sock, oob_data, strlen(oob_data), MSG_OOB);

        sleep(1);
        printf("send the normal_data: %s\n", normal_data);
        send(sock, normal_data, strlen(normal_data), 0);
    }
    
    printf("send over...,按任意键退出\n");
    getchar();
    close(sock);

    return 0;
}

在终端下输入：./practice_server_91 192.168.0.127 12345       //启动了服务器

在另外一个终端下输入：./56senddata 192.168.0.127 12345   //启动了客户端

服务器终端输出为：

get 3 bytes of normal data: 123
get 2 bytes of normal data: ab
get 1 bytes of oob data: c
get 3 bytes of normal data: 123


客户端终端输出为： 

send the normal_data: 123
send the oob_data: abc
send the normal_data: 123
send over...,按任意键退出


POLL实例

服务器和客户端用poll机制实现，服务器实现对客户端的响应的回显。服务器将客户端的输入直接回复。

服务器用poll机制实现对监听套接字和若干连接套接字进行I/O复用。

客户端用poll机制实现对连接套接字和标准输入文件描述符进行I/O复用。

服务器源代码：

/*************************************************************************
	> File Name: practice_91.c
	> Author: 
	> Mail: 
	> Created Time: 2016年02月24日 星期三 15时38分01秒
 ************************************************************************/
/*
能够同时接收普通数据和带外数据
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>
#include <poll.h>
#include <errno.h>

#define OPEN_MAX 1024

int do_poll(int listenfd)
{
    int connfd, sockfd;
    struct sockaddr_in cliaddr;
    socklen_t cliaddrlen = sizeof(cliaddr);

    struct pollfd clientfds[1024];
    int maxi;
    char buf[1024];
    int i, num;
    int nready;

    //添加监听文件描述符
    clientfds[0].fd = listenfd;
    clientfds[0].events = POLLIN;
    //初始化客户连接文件描述符
    for(i = 1; i < OPEN_MAX; ++i){
        clientfds[i].fd = -1;
    }

    maxi = 0;

    for(; ;){
        //获取就绪的文件描述符的个数
        nready = poll(clientfds, maxi+1, -1);
        if(nready == -1){
            printf("poll error\n");
            return -1;
        }
        //测试监听文件描述符是否就绪好
        if(clientfds[0].revents & POLLIN){
            //接受新的连接
            connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddrlen);
            if(connfd == -1){
                if(errno == EINTR)
                    continue;
                else{
                    printf("accept error\n");
                    return -1;
                }
            }

            printf("接受新的客户连接:%s:%d\n", inet_ntoa(cliaddr.sin_addr), cliaddr.sin_port);
            //将新的连接添加到数组中
            for(i = 1; i < OPEN_MAX; ++i){
                if(clientfds[i].fd < 0){
                    clientfds[i].fd = connfd;
                    break;
                }
            }

            if(i == OPEN_MAX){
                printf("too many clients\n");
                return -1;
            }

            clientfds[i].events = POLLIN;
            //记录客户连接套接字的个数
            maxi = (i > maxi ? i : maxi);

            if(--nready <= 0)
                continue;
        }

        //不是监听套接字就绪
        //处理客户连接，处理连接套接字
        //handle_connectin(clientfds, maxi);
        memset(buf, 0, 1024);

        for(i = 1; i <= maxi; ++i){
            if(clientfds[i].fd < 0)
                continue;
            //测试连接套接字是否就绪可读
            if(clientfds[i].revents & POLLIN){
                //有消息则读取到buf中
                num = read(clientfds[i].fd, buf, 1024);
            
                if(num == 0){
                    close(clientfds[i].fd);
                    clientfds[i].fd = -1;
                    continue;
                } 
                printf("server read the data is : %s", buf);
                write(clientfds[i].fd, buf, num);
            }
        }
    }
    
}

int main(int argc, char *argv[])
{
    if(argc <= 2){
        printf("%s ip_address port_number\n", 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);
    
    //socket
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if(listenfd < 0){
        printf("socket error\n");
        return -1;
    }

    //bind
    ret = bind(listenfd, (struct sockaddr *)&address, sizeof(address));
    if(ret != 0){
        printf("bind error\n");
        return -1;
    }

    //listen
    ret = listen(listenfd, 5);
    if(ret != 0){
        printf("listen error\n");
        return -1;
    }

    do_poll(listenfd);

    close(listenfd);

    return 0;
}

客户端源代码：

/*************************************************************************
	> File Name: poll_client.c
	> Author: 
	> Mail: 
	> Created Time: 2016年02月26日 星期五 20时25分24秒
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <poll.h>
#include <time.h>
#include <unistd.h>
#include <arpa/inet.h>


int handle_connection(int sockfd)
{
    char sendbuf[1024], recvbuf[1024];
    struct pollfd pfds[2];
    int num;
    //添加连接套接字
    pfds[0].fd = sockfd;
    pfds[0].events = POLLIN;
    //添加标准输入文件描述符
    pfds[1].fd = STDIN_FILENO;
    pfds[1].events = POLLIN;

    for(; ;){
        poll(pfds, 2, -1);
        //连接文件描述符准备好
        if(pfds[0].revents & POLLIN){
            num = read(sockfd, recvbuf, 1024);
            if(num == 0){
                printf("client: server closed.\n");
                close(sockfd);
            }
            //将收到的内容输出到标准输出
            write(STDOUT_FILENO, recvbuf, num);
        }
        //测试标准输入是否就绪
        if(pfds[1].revents & POLLIN){
            num = read(STDIN_FILENO, sendbuf, 1024);
            if(num == 0){
                continue;
            }
            write(sockfd, sendbuf, num);
        }
    }
    return 0;
}


int main(int argc, char *argv[])
{
    if(argc <= 2){
        printf("input the: %s ipaddr port", argv[0]);
        return -1;
    }
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in servaddr;
    bzero(&servaddr, sizeof(servaddr));

    const char * ip = argv[1];
    int port = atoi(argv[2]);

    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &servaddr.sin_addr);
    servaddr.sin_port = htons(port);

    connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    
    //处理连接套接字
    handle_connection(sockfd);

    return 0;
}

在终端1下输入：./poll_server 192.168.0.140 12345      //启动了服务器

在终端2下输入：./poll_client 192.168.0.140 12345   //启动了客户端1

client1 hello world
client1 hello world
client1 linux
client1 linux

在终端3下输入：./poll_client 192.168.0.140 12345   //启动了客户端2

client2 hello world
client2 hello world
client ^H
client 
client 2
client 2

服务器终端输出为：


接受新的客户连接:192.168.0.140:59023
server read the data is : client1 hello world
server read the data is : client1 linux
接受新的客户连接:192.168.0.140:59279
server read the data is : client2 hello world
server read the data is : client 
server read the data is : client 2




EPOLL实例

服务器通过选择不同的模式（LT,ET）来对连接套接字进行监听。用ET模式对监听套接字进行监听。将收到的数据输出到标准输出上显示。
客户端仅仅是从标准输入获得数据并发送到连接套接字上。

服务器源代码：

/*************************************************************************
	> File Name: epoll_server.c
	> Author: 
	> Mail: 
	> Created Time: 2016年02月27日 星期六 16时17分58秒
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <stdbool.h>
#include <fcntl.h>
#include <errno.h>
#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10

//设置文件描述符为非阻塞
int setnonblocking(int fd)
{
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

//将文件描述符fd添加到内核事件表中
void addfd(int epollfd, int fd, bool enable_et)
{
    struct epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN;
    if(enable_et)
        event.events |= EPOLLET;

    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}

//LT模式的工作流程
void lt(struct epoll_event * events, int number, int epollfd, int listenfd)
{
    char buf[BUFFER_SIZE];
    int i;
    for(i = 0; i < number; ++i){
        int sockfd = events[i].data.fd;
        if(sockfd == listenfd){//如果描述符是监听套接字
            struct sockaddr_in clientaddr;
            socklen_t clientaddr_len;
            int connfd = accept(sockfd, (struct sockaddr*)&clientaddr, &clientaddr_len);
            addfd(epollfd, connfd, false);//对connfd禁用et模式
        }
        else if(events[i].events & EPOLLIN){//如果不是监听套接字，则是连接套接字，如果可读则读取数据,LT模式
            printf("event trigger once\n");
            memset(buf, 0, BUFFER_SIZE);
            int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
            if(ret <= 0){
                close(sockfd);
                continue;
            }
            printf("get %d bytes data: %s\n", ret, buf);
        }
        else{
            printf("其它情况....\n");
        }
    }
}

//ET模式的工作流程
void et(struct epoll_event * events, int number, int epollfd, int listenfd)
{
    char buf[BUFFER_SIZE];
    int i;
    for(i = 0; i < number; ++i){
        int sockfd = events[i].data.fd;
        if(sockfd == listenfd){//如果描述符是监听套接字
            struct sockaddr_in clientaddr;
            socklen_t clientaddr_len;
            int connfd = accept(sockfd, (struct sockaddr*)&clientaddr, &clientaddr_len);
            addfd(epollfd, connfd, true);//对connfd开启et模式
        }
        else if(events[i].events & EPOLLIN){//如果不是监听套接字，则是连接套接字，如果可读则读取数据,ET模式，所以要重复的读完
            printf("event trigger once");
            while(1){
                memset(buf, 0, BUFFER_SIZE);
                int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
                if(ret < 0){
                    if((errno==EAGAIN) || (errno==EWOULDBLOCK)){//此时表示读取完毕
                        printf("read later, 此时读取完毕\n");
                        break;
                    }
                    close(sockfd);
                    break;   
                }
                else if(ret == 0){
                    close(sockfd);
                }
                else{
                    printf("\nget %d bytes data: %s", ret, buf);
                }
            }
        }
        else{
            printf("其它情况....\n");
        }
    }
}



int main(int argc, char *argv[])
{
    if(argc <= 3){
        printf("input: %s ip_addr port_num et or lt", argv[0]);
        return -1;
    }

    const char * ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in servaddr;
    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &servaddr.sin_addr);
    servaddr.sin_port = htons(port);

    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if(listenfd < 0){
        printf("socket error\n");
        return -1;
    }

    ret = bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
    if(ret < 0){
        printf("bind error\n");
        close(listenfd);
        return -1;
    }

    ret = listen(listenfd, 5);
    if(ret < 0){
        printf("listen error\n");
        close(listenfd);
        return -1;
    }

    struct epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    if(epollfd < 0){
        printf("epoll_create error\n");
        close(listenfd);
    }

    addfd(epollfd, listenfd, true);//true表示开启ET模式

    while(1){
        int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if(ret < 0){
            printf("epoll_wait error\n");
            break;
        }
        if(strncmp(argv[3], "lt", 2) == 0)
            lt(events, ret, epollfd, listenfd);
        else if(strncmp(argv[3], "et", 2) == 0)
            et(events, ret, epollfd, listenfd);
    }
    close(listenfd);

    return 0;
}

客户端源代码：

/*************************************************************************
	> File Name: 53backlog.c
	> Author: 
	> Mail: 
	> Created Time: 2016年01月16日 星期六 11时35分15秒
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <string.h>
#include <assert.h>
#include <stdbool.h>//包含bool类型，C语言是没有bool类型的，C++才有
#include <unistd.h>
#include <errno.h>

static bool stop = false;

static void handle_term(int sig)
{
    stop = true;
}

int main(int argc, char *argv[])
{
    signal(SIGTERM, handle_term);
    if(argc <= 2){
        printf("usage: %s ip_address port_number backlog\n", argv[0]);
        return 1;
    }

    const char * ip = argv[1];
    int port = atoi(argv[2]);
    int backlog = 5;//atoi(argv[3]);

    int sock = socket(AF_INET, SOCK_STREAM, 0);
    assert(sock >= 0);

    //创建ipv4的地址
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    address.sin_port = htons(port);
    inet_pton(AF_INET, ip, (void *)&address.sin_addr);

    int ret = connect(sock, (struct sockaddr *)&address, sizeof(address));
    if(ret < 0)
        printf("connect failed.\n");
    else{
        char buf[1024];
        int num = 0;
        
        while(1){
            num = read(STDIN_FILENO, buf, 1024);
            if(num <= 0){
                break;
            }
            write(sock, buf, num);
        }
    }
    
    printf("send over...,按任意键退出\n");
    getchar();
    close(sock);

    return 0;
}

以LT模式启动服务器：

在一个终端输入启动服务器：./epoll_server 192.168.56.101 12345 lt   //以LT模式启动该服务器
在另一个终端输入启动客户端: ./epoll_client 192.168.56.101 12345      //启动客户端
可以启动多个客户端连接到该服务器上。

客户端输入： 
linux
linuxeverreadwrite
haha

服务器输出： 
event trigger once
get 6 bytes data: linux

event trigger once
get 9 bytes data: linuxever
event trigger once
get 9 bytes data: readwrite
event trigger once
get 1 bytes data: 

event trigger once
get 5 bytes data: haha

可以发现第二次的数据比较多，一次不能读完，然后触发了该读事件3次。

以ET模式启动服务器：

在一个终端输入启动服务器：./epoll_server 192.168.56.101 12345 et  //以ET模式启动该服务器
在另一个终端输入启动客户端: ./epoll_client 192.168.56.101 12345      //启动客户端
可以启动多个客户端连接到该服务器上。

客户端输入：

linux
linuxeverreadwrite
haha

服务器输出：

event trigger once
get 6 bytes data: linux
read later, 此时读取完毕

event trigger once
get 9 bytes data: linuxever
get 9 bytes data: readwrite
get 1 bytes data: 
read later, 此时读取完毕

event trigger once
get 5 bytes data: haha
read later, 此时读取完毕


EPOLL使用EPOLLONESHOT事件：

服务器中对每个连接套接字可读就绪的时候创建新的工作线程去处理数据。如果在该线程读取完毕，处理数据过程中，如果该套接字上又有数据输入了，如果没有注册epolloneshot事件则还会创建新的线程去处理数据，那么就会有多个线程同时处理一个连接套接字，这样会出现错误的。所以在连接套接字上注册了epolloneshot事件，那么只能有一个线程在处理该套接字。当该线程处理完数据之后，重新注册该事件，再次检测到epollin事件的时候再创建一个线程去处理数据。

服务器源代码：

/*************************************************************************
	> File Name: epoll_server.c
	> Author: 
	> Mail: 
	> Created Time: 2016年02月27日 星期六 16时17分58秒
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <stdbool.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>

#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 1024

struct fds
{
    int epollfd;
    int sockfd;
};

//设置文件描述符为非阻塞
int setnonblocking(int fd)
{
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

//将文件描述符fd添加到内核事件表中
void addfd(int epollfd, int fd, bool oneshot)
{
    struct 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);
}

void reset_oneshot(int epollfd, int fd)
{
    struct epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
    epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);
}

//处理连接套接字上的数据
void* worker(void* arg)
{
    int sockfd = ((struct fds*)arg)->sockfd;
    int epollfd = ((struct fds*)arg)->epollfd;

    printf("####start new thread to receive data on fd: %d\n", sockfd);

    char buf[BUFFER_SIZE];
    memset(buf, 0, BUFFER_SIZE);

    int ret;
    while(1){
        ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
        if(ret == 0){
            close(sockfd);
            printf("对端关闭了连接\n");
            break;
        }
        else if(ret < 0){
            if(errno == EAGAIN){
                reset_oneshot(epollfd, sockfd);
               //printf("read later\n");
                break;
            }
        }
        else{
            printf("get %d bytes data: %s\n", ret, buf);
            sleep(4);//模拟此时是正在处理数据 
        }
        memset(buf, 0, BUFFER_SIZE);
    }
    printf("####end new thread receiving data on fd: %d\n", sockfd);
}


int main(int argc, char *argv[])
{
    int i;

    if(argc <= 2){
        printf("input: %s ip_addr port_num\n", argv[0]);
        return -1;
    }

    const char * ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in servaddr;
    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &servaddr.sin_addr);
    servaddr.sin_port = htons(port);

    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if(listenfd < 0){
        printf("socket error\n");
        return -1;
    }

    ret = bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
    if(ret < 0){
        printf("bind error\n");
        close(listenfd);
        return -1;
    }

    ret = listen(listenfd, 5);
    if(ret < 0){
        printf("listen error\n");
        close(listenfd);
        return -1;
    }

    struct epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    if(epollfd < 0){
        printf("epoll_create error\n");
        close(listenfd);
    }

    addfd(epollfd, listenfd, false);

    while(1){
        int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if(ret < 0){
            printf("epoll_wait error\n");
            break;
        }
        for(i = 0; i < ret; ++i){
            int sockfd = events[i].data.fd;
            if(sockfd == listenfd){
                struct sockaddr_in client_address;
                socklen_t client_addresslen = sizeof(client_address);
                int connfd = accept(sockfd, (struct sockaddr*)&client_address, &client_addresslen);
                //对连接套接字注册oneshot事件
                addfd(epollfd, connfd, true);
            }
            else if(events[i].events & EPOLLIN){
                pthread_t thread;
                struct fds fds_for_new_worker;
                fds_for_new_worker.sockfd = sockfd;
                fds_for_new_worker.epollfd = epollfd;
                //启动新的进程为连接socket服务
                pthread_create(&thread, NULL, worker, (void*)&fds_for_new_worker);
            }
            else{
                printf("发生了其它情况\n");
            }
        }
    }
    close(listenfd);

    return 0;
}


客户端源代码同上一样

客户端输入： 

linux
lin
lin
lin
linsadfasdf（输入之后等待超过4秒）
linuxever  //此时会启动新的工作线程
liin

服务器输出： 

####start new thread to receive data on fd: 5
get 6 bytes data: linux

get 4 bytes data: lin

get 4 bytes data: lin

get 4 bytes data: lin

get 12 bytes data: linsadfasdf

####end new thread receiving data on fd: 5
####start new thread to receive data on fd: 5
get 10 bytes data: linuxever

get 5 bytes data: liin

####end new thread receiving data on fd: 5


参考文章：

http://www.cnblogs.com/Anker/p/3265058.html

http://www.cnblogs.com/Anker/archive/2013/08/14/3258674.html

http://www.cnblogs.com/Anker/archive/2013/08/15/3261006.html

http://www.cnblogs.com/Anker/archive/2013/08/17/3263780.html

高并发网络编程之epoll详解

epoll机制:epoll_create、epoll_ctl、epoll_wait、close

Linux Epoll介绍和程序实例

linux epoll机制

readyao
关注
专栏目录
I/O 多路复用之poll
Ming
08-08 825
概述 poll() 系统调用是System V 的I/O多路复用的解决方案。它解决了一些 select() 的不足，不过 select() 还是被频繁的使用（还是出于习惯或可移植性的考虑）。 Poll()        #include        int poll(struct pollfd *fds, nfds_t nfds, int timeout); select() 使用了
《Linux高性能服务器编程》---读书笔记（三）---复用I/O总结、Epoll详解、I/O框架库libevent
阿龙的博客
01-20 366
I/O复用 使得程序同时监听多个文件描述符。但是其本身是阻塞的。监听的同时就绪时，会顺序依次处理。主要有select， poll， epoll。 select： select I/O复用系统调用，使用fd_set这个结构来存储文件描述符，以bit表示。并且有最大限制(好像是1024*8)。 将可读，可写，异常的三组fd_set传入，然后如果有可读可写异常，则会修改对应的fd_set的标志位以告知用户。 书里提到了就绪条件，供参考： 对于标志位的结果，需要通过轮询的方式来查找，效率很低。
基于epoll的并发服务器编程
qq_34915586的博客
12-01 246
这一篇文章主要是理清服务器和客户端的建立通信的流程，整个通信是在网络层(即ip协议以及其上的传输层和应用层)。不明白的话需要先了解网络7层模型、对应的报文格式和不同层的封装。 下面主要围绕图11-14讲述并深入探讨 服务器 socket #include <sys/types.h> #include <sys/socket.h> int socket(int...
多线程中的EPOLLONESHOT
luseysd的博客
11-21 3662
epoll中EPOLLSHOT的使用 EPOLLSHOT的作用主要用于多线程中 epoll在某次循环中唤醒一个事件，并用某个工作进程去处理该fd，此后如果不注册EPOLLSHOT,在该fd时间如果工作线程处理的不及时，主线程仍会唤醒这个时间，并另派线程池中另一个线程也来处理这个fd。 为了避免这种情况，需要在注册时间时加上EPOLLSHOT标志，EPOLLSHOT相当于说，某次循环中epoll_wait唤醒该事件fd后，就会从注册中删除该fd,也就是说以后不会epollfd的表格中将不会再有这个fd,也就不
epoll的LT和ET使用EPOLLONESHOT
热门推荐
迷路的专栏
07-16 1万+
epoll的总结之四LT和ET使用EPOLLONESHOT 在前面说过，epoll有两种触发的方式即LT（水平触发）和ET（边缘触发）两种，在前者，只要存在着事件就会不断的触发，直到处理完成，而后者只触发一次相同事件或者说只在从非触发到触发两个状态转换的时候儿才触发。 这会出现下面一种情况，如果是多线程在处理，一个SOCKET事件到来，数据开始解析，这时候这个SOCKET又来了同样一个这样的事
Linux系统编程——I/O多路复用select、poll、epoll
墨鱼菜鸡
07-11 395
参考：https://segmentfault.com/a/1190000003063859 Linux下的I/O复用与epoll详解：https://www.cnblogs.com/lojunren/p/3856290.html 彻底学会 epoll 系列：http://blog.chinaunix.net/uid/28541347/sid-1931...
【计算机网络】——I/O复用之epoll
qq_43412060的博客
07-02 524
1、epoll概述 2、epoll函数的功能和作用 3、epoll的特点 4、epoll代码实现
三种I/O复用方式——select、poll和epoll
szy0321的博客
03-05 651
为什么要引入I/O复用： TCP服务器在与客户端完成建立连接，并在完成整个交互过程之后再断开连接。在服务端的代码中，在收发数据时加上一个while循环,用于解决同一个客户端的多次收发数据请求。但当多个客户端同时向服务器发出请求时，当前的服务器无法满足要求，所以引入了I/O复用，可以使程序同时监听多个文件描述符，这样能使程序的性能提高。 I/O复用的场景： 1.TCP服务器需要同时处理监听socket、连接socket 2.服务器要同时接听多个端口 3.客户端程序要同时处理用户输入和网络连接 4.程序要同时处
I/O复用——select/poll/epoll的比较
Y~哈哈哈的博客
02-28 145
select： select本质上是通过设置或者检查存放fd标志位的数据结构来进行下一步处理。这样所带来的缺点是： 1、 单个进程可监视的fd数量被限制，即能监听端口的大小有限。 一般来说这个数目和系统内存关系很大，具体数目可以cat /proc/sys/fs/file-max察看。32位机默认是1024个。64位机默认是2048. 2、 对socket进行扫描时是线性扫描，即...
【计算机网络】——I/O复用三种方式总结
qq_43412060的博客
07-02 990
1、引言 在之前的博文中，我们陆续的介绍了I/O复用的三种技术——select、poll和epoll。 调用这三组系统调用能够同时监听多个文件描述符。直到一个或者多个文件描述符上有事件发生时返回，返回值就是就绪的文件描述符的数量。 现在，我们主要从事件集合的记录方式、最大支持文件描述符数、工作模式和具体实现几个方面进一步比较他们的异同。 2、比较 1、事件集合 这三种方式都是通过某种结构体变量来告诉内核监听哪些文件描述符及其事件。具体的区别如下： select的参数类型是fd_set的文件描述符集合。因为
EPOLLONESHOT事件
liuxuejiang158的专栏
10-08 9464
epoll模式中事件可能被触发多次，比如socket接收到数据交给一个线程处理数据，在数据没有处理完之前又有新数据达到触发了事件，另一个线程被激活获得该socket，从而产生多个线程操作同一socket，即使在ET模式下也有可能出现这种情况。采用EPOLLONETSHOT事件的文件描述符上的注册事件只触发一次，要想重新注册事件则需要调用epoll_ctl重置文件描述符上的事件，这样前面的socke
EPOLLONESHOT
tus00000的博客
08-04 554
EPOLL的EPOLLONESHOT事件，使一个socket连接任何时刻都只被一个线程所处理，对于注册了EPOLLONESHOT事件的socket，操作系统最多触发其上注册的一个可读、可写、或者异常事件，且只触发一次，这样，当一个线程在处理某个socket时，其他线程是不可能有机会操作该socket的，但反过来，注册了EPOLLONESHOT事件的socket一旦被某个线程处理完毕，该线程就应该立即重置这个socket上的EPOLLONESHOT事件，以确保这个socket下一次可读，其他工作线程有机会继续
epoll在并发编程中同步问题的解决-----EPOLLONESHOT事件
城南花已开的博客
06-25 660
无论epoll处于LT模式还是ET模式下，一个socket上的某个事件都可能会被触发多次。这在并发编程中会引起一个问题，比如一个线程在读取完某个socket上的数据后开始处理数据，而在处理数据的过程中又触发可读事件，这样会有另外一个线程读取新的数据，这样就会出现两个线程同时操作一个socket的问题。 上述问题可以通过epoll中的EPOLLONESHOT事件来解决,对于注册EPOLLONESHOT事件的文件描述符来说，只会触发一次事件，除非使用epoll_ctl函数重置该文件描述符上注册的EPOLLONE
EPOLLONESHOT选项
qq_36553387的博客
07-18 373
EPOLLONESHOT选项 如果某个socket注册了该标志，则其注册监听的事件在触发一次后再也不会触发，除非重新注册监听该事件类型。 //epoll_server_with_oneshot.cpp #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <unistd.h> #include <fcntl.h> #include <sys
Linux编程入门三网络编程三 epoll的LT和ET模式以及EPOLLONESHOT事件
肥叔菌的博客
05-13 9714
epoll对文件描述符的操作有两种模式：LT(Level Trigger 电平触发)模式和ET(Edge Trigger 边沿触发)模式。 LT是默认的工作模式，这种模式下epoll相当于一个效率较高的poll。对于采用LT工作模式的文件描述符，当epoll_wait检测到其上有事件发生并将此事件通知应用程序后，应用程序可以不立即处理该使事件。这样，当应用程序下一次调用epoll_wait时，ep...
EPOLLONESHOT及其引发的EPOLL在ET能被多次触发吗？
mijichui2153的博客
07-11 1109
  以下是《Linux高性能服务器编程》对EPOLLONESHOT的描述： 对于注册了EPOLLONESHOT的文件描述符，操作系统最多触发其上注册的一个可读、可写或者异常的事件，且只触发一次，除非我们使用epoll_ctl函数重置该文件描述符上注册的EPOLLONESHOT事件。   乍一看会以为EPOLLONESHOT不就是ET模式相对于LT模式的区别，仔细阅读之后发现原来ET和EP...
epoll EPOLLONESHOT 事件
le119126的专栏
06-04 6769
eppll 即使使用ET模式，一个socket上的某个事件还是可能被触发多次，采用线程城池的方式来处理事件，可能一个socket同时被多个线程处理 如果对描述符socket注册了EPOLLONESHOT事件，那么操作系统最多触发其上注册的一个可读、可写或者异常事件，且只触发一次。。想要下次再触发则必须使用epoll_ctl重置该描述符上注册的事件，包括EPOLLONESHOT 事件。 例子：
5.6EPOLLONESHOT事件
l_ethan的博客
07-10 585
即使可以使用 ET 模式，一个socket 上的某个事件还是可能被触发多次。这在并发程序中就会引起一个 问题。比如一个线程在读取完某个 socket 上的数据后开始处理这些数据，而在数据的处理过程中该 socket 上又有新数据可读（EPOLLIN 再次被触发），此时另外一个线程被唤醒来读取这些新的数据。于 是就出现了两个线程同时操作一个 socket 的局面。一个socket连接在任一时刻都只被一个线程处理，可 以使用 epoll 的 EPOLLONESHOT 事件实现。 对于注册了EPOLLONESHO
UNIX网络编程基础：套接字编程和I/O复用
I/O复用是指多个套接字可以共享同一个描述符的技术，包括select、pselect、poll和epoll四种方式。select函数是最基本的I/O复用函数，可以监控多个套接字的就绪状态。pselect函数是select函数的变种，可以指定超时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值