【Linux下epoll编程1】epoll编程的引出_先来看多进程Socket通信源码+演示

这篇博客只是为了引出Linux下epoll编程，其实本博客之前就有过Linux下socket编程的相关系列教程，如下：

【整理】Linux Socket网络编程_TCP编程(1)_基础版本
【整理】Linux Socket网络编程_TCP编程(2)_多进程版本
【整理】Linux Socket网络编程_TCP编程(3)_多线程版本
【整理】Linux Socket网络编程_TCP编程(4)_C++与PythonSocket通信

我们的需求是，每有一个客户端连接上来，便创建一个单独的通信进程进行通信。

Server端的代码：

#include  <unistd.h>
#include  <sys/types.h>       /* basic system data types */
#include  <sys/socket.h>      /* basic socket definitions */
#include  <netinet/in.h>      /* sockaddr_in{} and other Internet defns */
#include  <arpa/inet.h>       /* inet(3) functions */

#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>

#define MAXLINE 1024
//typedef struct sockaddr  SA;
void handle(int connfd);

int  main(int argc, char **argv)
{
    int     listenfd, connfd;
    int  serverPort = 6888;
    int listenq = 1024;
    pid_t   childpid;
    char buf[MAXLINE];
    socklen_t socklen;

    struct sockaddr_in cliaddr, servaddr;
    socklen = sizeof(cliaddr);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(serverPort);

    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd < 0) {
        perror("socket error");
        return -1;
    }
    if (bind(listenfd, (struct sockaddr *) &servaddr, socklen) < 0) {
        perror("bind error");
        return -1;
    }
    if (listen(listenfd, listenq) < 0) {
        perror("listen error");    
        return -1;
    }
    printf("echo server startup,listen on port:%d\n", serverPort);
    for ( ; ; )  {
        connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &socklen);
        if (connfd < 0) {
            perror("accept error");
            continue;
        }

        sprintf(buf, "accept form %s:%d\n", inet_ntoa(cliaddr.sin_addr), cliaddr.sin_port);
        printf(buf,"");
        childpid = fork();
        if (childpid == 0) { /* child process */
            close(listenfd);    /* close listening socket */
            handle(connfd);   /* process the request */
            exit (0);
        } else if (childpid > 0)  {
            close(connfd);          /* parent closes connected socket */
        } else {
            perror("fork error");
        }
    }
}


void handle(int connfd)
{
    size_t n;
    char buf[MAXLINE];

    for(;;) {
        n = read(connfd, buf, MAXLINE);
        if (n < 0) {
            if(errno != EINTR) {
                perror("read error");
                break;
            }
        }
        if (n == 0) {
            //connfd is closed by client
            close(connfd);
            printf("client exit\n");
            break;
        }
        //client exit
        if (strncmp("exit", buf, 4) == 0) {
            close(connfd);
            printf("client exit\n");
            break;
        }
        write(connfd, buf, n); //write maybe fail,here don't process failed error
    } 
}

Client端的代码：

#include  <unistd.h>
#include  <sys/types.h>       /* basic system data types */
#include  <sys/socket.h>      /* basic socket definitions */
#include  <netinet/in.h>      /* sockaddr_in{} and other Internet defns */
#include  <arpa/inet.h>       /* inet(3) functions */
#include <netdb.h> /*gethostbyname function */

#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>

#define MAXLINE 1024

void handle(int connfd);

int main(int argc, char **argv)
{
    char * servInetAddr = "127.0.0.1";
    int servPort = 6888;
    char buf[MAXLINE];
    int connfd;
    struct sockaddr_in servaddr;

    if (argc == 2) {
        servInetAddr = argv[1];
    }
    if (argc == 3) {
        servInetAddr = argv[1];
        servPort = atoi(argv[2]);
    }
    if (argc > 3) {
        printf("usage: echoclient <IPaddress> <Port>\n");
        return -1;
    }

    connfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(servPort);
    inet_pton(AF_INET, servInetAddr, &servaddr.sin_addr);

    if (connect(connfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) {
        perror("connect error");
        return -1;
    }
    printf("welcome to echoclient\n");
    handle(connfd);     /* do it all */
    close(connfd);
    printf("exit\n");
    exit(0);
}

void handle(int sockfd)
{
    char sendline[MAXLINE], recvline[MAXLINE];
    int n;
    for (;;) {
        if (fgets(sendline, MAXLINE, stdin) == NULL) {
            break;//read eof
        }
        /*
        //也可以不用标准库的缓冲流,直接使用系统函数无缓存操作
        if (read(STDIN_FILENO, sendline, MAXLINE) == 0) {
            break;//read eof
        }
        */

        n = write(sockfd, sendline, strlen(sendline));
        n = read(sockfd, recvline, MAXLINE);
        if (n == 0) {
            printf("echoclient: server terminated prematurely\n");
            break;
        }
        write(STDOUT_FILENO, recvline, n);
        //如果用标准库的缓存流输出有时会出现问题
        //fputs(recvline, stdout);
    }
}

演示效果：

我们建立多次会话之后，发现每次建立一次连接，便会创建一个进程：

假如会话数量是100，那么就有100个进程，如果是成千上万呢？这种方式从性能上分析显然不行，每个进程占据的内存，cpu资源都是比较大的。虽然这个是多进程版本，其实换成多线程版本，也一样存在这种瓶颈，当建立的连接达到成千上万后，这种多线程、多进程版本的socket通信就不能满足高性能的需求了。进程的开销，线程的切换，都是性能开销。

那么我们应该采取什么样的方式进行性能提升呢？

这里我们就需要Linux下的epoll编程了，那么什么是epoll呢？可以参考知乎上某大神的回答：

说来说去，epoll是Linux 内核层面上支持的一种技术，性能出众。更多了解可以参考：

epoll 或者 kqueue 的原理是什么？

epoll事件处理机制详解

Epoll模型详解

彻底学会使用epoll(一)——ET模式实现分析

彻底学会使用epoll（二）——ET和LT的触发方式

彻底学会使用epoll（三）——ET的读操作实例分析

彻底学会使用epoll（四）——ET的写操作实例分析

彻底学会使用epoll(五)—— ET模式下的注意事项

彻底学会使用epoll(六)——关于ET的若干问题总结

综上，为了支持更高性能级别的socket server，我们需要将我们的代码改为epoll。在下一文中，我们将把代码改为epoll模式代码。

文章的脚注信息由WordPress的wp-posturl插件自动生成

打赏

微信扫一扫，打赏作者吧～