05高并发服务器

最新推荐文章于 2024-01-26 15:00:29 发布
最新推荐文章于 2024-01-26 15:00:29 发布
阅读量198 收藏
点赞数 1
分类专栏： 计算机网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nmjhehe/article/details/115917415
版权

 

高并发服务器

 

多进程并发服务器

使用多进程并发服务器时要考虑以下几点：

  1. 父进程最大文件描述个数(父进程中需要close关闭accept返回的新文件描述符)
  2. 系统内创建进程个数(与内存大小相关)
  3. 进程创建过多是否降低整体服务性能(进程调度)

server

/* server.c */

#include <stdio.h>

#include <string.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <signal.h>

#include <sys/wait.h>

#include <sys/types.h>

#include "wrap.h"

 

#define MAXLINE 80

#define SERV_PORT 800

 

void do_sigchild(int num)

{

    while (waitpid(0, NULL, WNOHANG) > 0)

        ;

}

int main(void)

{

    struct sockaddr_in servaddr, cliaddr;

    socklen_t cliaddr_len;

    int listenfd, connfd;

    char buf[MAXLINE];

    char str[INET_ADDRSTRLEN];

    int i, n;

    pid_t pid;

 

    struct sigaction newact;

    newact.sa_handler = do_sigchild;

    sigemptyset(&newact.sa_mask);

    newact.sa_flags = 0;

    sigaction(SIGCHLD, &newact, NULL);

 

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    servaddr.sin_port = htons(SERV_PORT);

 

    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    Listen(listenfd, 20);

 

    printf("Accepting connections ...\n");

    while (1) {

        cliaddr_len = sizeof(cliaddr);

        connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

 

        pid = fork();

        if (pid == 0) {

            Close(listenfd);

            while (1) {

                n = Read(connfd, buf, MAXLINE);

                if (n == 0) {

                    printf("the other side has been closed.\n");

                    break;

                }

                printf("received from %s at PORT %d\n",

                        inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),

                        ntohs(cliaddr.sin_port));

                for (i = 0; i < n; i++)

                    buf[i] = toupper(buf[i]);

                Write(connfd, buf, n);

            }

            Close(connfd);

            return 0;

        } else if (pid > 0) {

            Close(connfd);

        } else

            perr_exit("fork");

    }

    Close(listenfd);

    return 0;

}

client

/* client.c */

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <netinet/in.h>

#include "wrap.h"

 

#define MAXLINE 80

#define SERV_PORT 6666

 

int main(int argc, char *argv[])

{

    struct sockaddr_in servaddr;

    char buf[MAXLINE];

    int sockfd, n;

 

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);

    servaddr.sin_port = htons(SERV_PORT);

 

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    while (fgets(buf, MAXLINE, stdin) != NULL) {

        Write(sockfd, buf, strlen(buf));

        n = Read(sockfd, buf, MAXLINE);

        if (n == 0) {

            printf("the other side has been closed.\n");

            break;

        } else

            Write(STDOUT_FILENO, buf, n);

    }

    Close(sockfd);

    return 0;

}

 

多线程并发服务器

在使用线程模型开发服务器时需考虑以下问题：

  1. 调整进程内最大文件描述符上限
  2. 线程如有共享数据，考虑线程同步
  3. 服务于客户端线程退出时，退出处理。（退出值，分离态）
  4. 系统负载，随着链接客户端增加，导致其它线程不能及时得到CPU

server

/* server.c */

#include <stdio.h>

#include <string.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <pthread.h>

 

#include "wrap.h"

#define MAXLINE 80

#define SERV_PORT 6666

 

struct s_info {

    struct sockaddr_in cliaddr;

    int connfd;

};

void *do_work(void *arg)

{

    int n,i;

    struct s_info *ts = (struct s_info*)arg;

    char buf[MAXLINE];

    char str[INET_ADDRSTRLEN];

    /* 可以在创建线程前设置线程创建属性,设为分离态,哪种效率高内？ */

    pthread_detach(pthread_self());

    while (1) {

        n = Read(ts->connfd, buf, MAXLINE);

        if (n == 0) {

            printf("the other side has been closed.\n");

            break;

        }

        printf("received from %s at PORT %d\n",

                inet_ntop(AF_INET, &(*ts).cliaddr.sin_addr, str, sizeof(str)),

                ntohs((*ts).cliaddr.sin_port));

        for (i = 0; i < n; i++)

            buf[i] = toupper(buf[i]);

        Write(ts->connfd, buf, n);

    }

    Close(ts->connfd);

}

 

int main(void)

{

    struct sockaddr_in servaddr, cliaddr;

    socklen_t cliaddr_len;

    int listenfd, connfd;

    int i = 0;

    pthread_t tid;

    struct s_info ts[256];

 

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    servaddr.sin_port = htons(SERV_PORT);

 

    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    Listen(listenfd, 20);

 

    printf("Accepting connections ...\n");

    while (1) {

        cliaddr_len = sizeof(cliaddr);

        connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

        ts[i].cliaddr = cliaddr;

        ts[i].connfd = connfd;

        /* 达到线程最大数时，pthread_create出错处理, 增加服务器稳定性 */

        pthread_create(&tid, NULL, do_work, (void*)&ts[i]);

        i++;

    }

    return 0;

}

client

/* client.c */

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <netinet/in.h>

#include "wrap.h"

#define MAXLINE 80

#define SERV_PORT 6666

int main(int argc, char *argv[])

{

    struct sockaddr_in servaddr;

    char buf[MAXLINE];

    int sockfd, n;

 

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);

    servaddr.sin_port = htons(SERV_PORT);

 

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    while (fgets(buf, MAXLINE, stdin) != NULL) {

        Write(sockfd, buf, strlen(buf));

        n = Read(sockfd, buf, MAXLINE);

        if (n == 0)

            printf("the other side has been closed.\n");

        else

            Write(STDOUT_FILENO, buf, n);

    }

    Close(sockfd);

    return 0;

}

多路I/O转接服务器

多路IO转接服务器也叫做多任务IO服务器。该类服务器实现的主旨思想是，不再由应用程序自己监视客户端连接，取而代之由内核替应用程序监视文件。

主要使用的方法有三种

select

  1. select能监听的文件描述符个数受限于FD_SETSIZE,一般为1024，单纯改变进程打开的文件描述符个数并不能改变select监听文件个数
  2. 解决1024以下客户端时使用select是很合适的，但如果链接客户端过多，select采用的是轮询模型，会大大降低服务器响应效率，不应在select上投入更多精力

#include <sys/select.h>

/* According to earlier standards */

#include <sys/time.h>

#include <sys/types.h>

#include <unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds,

            fd_set *exceptfds, struct timeval *timeout);

 

    nfds:       监控的文件描述符集里最大文件描述符加1，因为此参数会告诉内核检测前多少个文件描述符的状态

    readfds：   监控有读数据到达文件描述符集合，传入传出参数

    writefds：  监控写数据到达文件描述符集合，传入传出参数

    exceptfds： 监控异常发生达文件描述符集合,如带外数据到达异常，传入传出参数

    timeout：   定时阻塞监控时间，3种情况

                1.NULL，永远等下去

                2.设置timeval，等待固定时间

                3.设置timeval里时间均为0，检查描述字后立即返回，轮询

    struct timeval {

        long tv_sec; /* seconds */

        long tv_usec; /* microseconds */

    };

    void FD_CLR(int fd, fd_set *set);   //把文件描述符集合里fd清0

    int FD_ISSET(int fd, fd_set *set); //测试文件描述符集合里fd是否置1

    void FD_SET(int fd, fd_set *set);   //把文件描述符集合里fd位置1

    void FD_ZERO(fd_set *set);          //把文件描述符集合里所有位清0

server

/* server.c */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include "wrap.h"

 

#define MAXLINE 80

#define SERV_PORT 6666

 

int main(int argc, char *argv[])

{

    int i, maxi, maxfd, listenfd, connfd, sockfd;

    int nready, client[FD_SETSIZE]; /* FD_SETSIZE 默认为 1024 */

    ssize_t n;

    fd_set rset, allset;

    char buf[MAXLINE];

    char str[INET_ADDRSTRLEN];          /* #define INET_ADDRSTRLEN 16 */

    socklen_t cliaddr_len;

    struct sockaddr_in cliaddr, servaddr;

 

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

 

bzero(&servaddr, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

servaddr.sin_port = htons(SERV_PORT);

 

Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

Listen(listenfd, 20);       /* 默认最大128 */

 

maxfd = listenfd;           /* 初始化 */

maxi = -1;                  /* client[]的下标 */

 

for (i = 0; i < FD_SETSIZE; i++)

    client[i] = -1;     /* 用-1初始化client[] */

 

FD_ZERO(&allset);

FD_SET(listenfd, &allset); /* 构造select监控文件描述符集 */

 

for ( ; ; ) {

    rset = allset;          /* 每次循环时都从新设置select监控信号集 */

    nready = select(maxfd+1, &rset, NULL, NULL, NULL);

 

    if (nready < 0)

        perr_exit("select error");

    if (FD_ISSET(listenfd, &rset)) { /* new client connection */

        cliaddr_len = sizeof(cliaddr);

        connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

        printf("received from %s at PORT %d\n",

                inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),

                ntohs(cliaddr.sin_port));

        for (i = 0; i < FD_SETSIZE; i++) {

            if (client[i] < 0) {

                client[i] = connfd; /* 保存accept返回的文件描述符到client[]里 */

                break;

            }

        }

        /* 达到select能监控的文件个数上限 1024 */

        if (i == FD_SETSIZE) {

            fputs("too many clients\n", stderr);

            exit(1);

        }

 

        FD_SET(connfd, &allset);    /* 添加一个新的文件描述符到监控信号集里 */

        if (connfd > maxfd)

            maxfd = connfd;     /* select第一个参数需要 */

        if (i > maxi)

            maxi = i;               /* 更新client[]最大下标值 */

 

        if (--nready == 0)

            continue;               /* 如果没有更多的就绪文件描述符继续回到上面select阻塞监听,

                                        负责处理未处理完的就绪文件描述符 */

        }

        for (i = 0; i <= maxi; i++) {   /* 检测哪个clients 有数据就绪 */

            if ( (sockfd = client[i]) < 0)

                continue;

            if (FD_ISSET(sockfd, &rset)) {

                if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {

                    Close(sockfd);      /* 当client关闭链接时，服务器端也关闭对应链接 */

                    FD_CLR(sockfd, &allset); /* 解除select监控此文件描述符 */

                    client[i] = -1;

                } else {

                    int j;

                    for (j = 0; j < n; j++)

                        buf[j] = toupper(buf[j]);

                    Write(sockfd, buf, n);

                }

                if (--nready == 0)

                    break;

            }

        }

    }

    close(listenfd);

    return 0;

}

client

/* client.c */

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <netinet/in.h>

#include "wrap.h"

 

#define MAXLINE 80

#define SERV_PORT 6666

 

int main(int argc, char *argv[])

{

    struct sockaddr_in servaddr;

    char buf[MAXLINE];

    int sockfd, n;

 

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);

    servaddr.sin_port = htons(SERV_PORT);

 

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    while (fgets(buf, MAXLINE, stdin) != NULL) {

        Write(sockfd, buf, strlen(buf));

        n = Read(sockfd, buf, MAXLINE);

        if (n == 0)

            printf("the other side has been closed.\n");

        else

            Write(STDOUT_FILENO, buf, n);

    }

    Close(sockfd);

    return 0;

}

pselect

pselect原型如下。此模型应用较少，有需要的同学可参考select模型自行编写C/S

#include <sys/select.h>

int pselect(int nfds, fd_set *readfds, fd_set *writefds,

            fd_set *exceptfds, const struct timespec *timeout,

            const sigset_t *sigmask);

    struct timespec {

        long tv_sec; /* seconds */

        long tv_nsec; /* nanoseconds */

    };

    用sigmask替代当前进程的阻塞信号集，调用返回后还原原有阻塞信号集

poll

#include <poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

    struct pollfd {

        int fd; /* 文件描述符 */

        short events; /* 监控的事件 */

        short revents; /* 监控事件中满足条件返回的事件 */

    };

    POLLIN         普通或带外优先数据可读,即POLLRDNORM | POLLRDBAND

    POLLRDNORM      数据可读

    POLLRDBAND      优先级带数据可读

    POLLPRI     高优先级可读数据

    POLLOUT        普通或带外数据可写

    POLLWRNORM      数据可写

    POLLWRBAND      优先级带数据可写

    POLLERR        发生错误

    POLLHUP     发生挂起

    POLLNVAL        描述字不是一个打开的文件

 

    nfds            监控数组中有多少文件描述符需要被监控

 

    timeout     毫秒级等待

        -1：阻塞等，#define INFTIM -1                 Linux中没有定义此宏

        0：立即返回，不阻塞进程

        >0：等待指定毫秒数，如当前系统时间精度不够毫秒，向上取值

如果不再监控某个文件描述符时，可以把pollfd中，fd设置为-1，poll不再监控此pollfd，下次返回时，把revents设置为0。

server

/* server.c */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <poll.h>

#include <errno.h>

#include "wrap.h"

 

#define MAXLINE 80

#define SERV_PORT 6666

#define OPEN_MAX 1024

 

int main(int argc, char *argv[])

{

    int i, j, maxi, listenfd, connfd, sockfd;

    int nready;

    ssize_t n;

    char buf[MAXLINE], str[INET_ADDRSTRLEN];

    socklen_t clilen;

    struct pollfd client[OPEN_MAX];

    struct sockaddr_in cliaddr, servaddr;

 

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    servaddr.sin_port = htons(SERV_PORT);

 

    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    Listen(listenfd, 20);

 

    client[0].fd = listenfd;

    client[0].events = POLLRDNORM;                  /* listenfd监听普通读事件 */

 

    for (i = 1; i < OPEN_MAX; i++)

        client[i].fd = -1;                          /* 用-1初始化client[]里剩下元素 */

    maxi = 0;                                       /* client[]数组有效元素中最大元素下标 */

 

    for ( ; ; ) {

        nready = poll(client, maxi+1, -1);          /* 阻塞 */

        if (client[0].revents & POLLRDNORM) {       /* 有客户端链接请求 */

            clilen = sizeof(cliaddr);

            connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);

            printf("received from %s at PORT %d\n",

                    inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),

                    ntohs(cliaddr.sin_port));

            for (i = 1; i < OPEN_MAX; i++) {

                if (client[i].fd < 0) {

                    client[i].fd = connfd; /* 找到client[]中空闲的位置，存放accept返回的connfd */

                    break;

                }

            }

 

            if (i == OPEN_MAX)

                perr_exit("too many clients");

 

            client[i].events = POLLRDNORM;      /* 设置刚刚返回的connfd，监控读事件 */

            if (i > maxi)

                maxi = i;                       /* 更新client[]中最大元素下标 */

            if (--nready <= 0)

                continue;                       /* 没有更多就绪事件时,继续回到poll阻塞 */

        }

        for (i = 1; i <= maxi; i++) {           /* 检测client[] */

            if ((sockfd = client[i].fd) < 0)

                continue;

            if (client[i].revents & (POLLRDNORM | POLLERR)) {

                if ((n = Read(sockfd, buf, MAXLINE)) < 0) {

                    if (errno == ECONNRESET) { /* 当收到 RST标志时 */

                        /* connection reset by client */

                        printf("client[%d] aborted connection\n", i);

                        Close(sockfd);

                        client[i].fd = -1;

                    } else {

                        perr_exit("read error");

                    }

                } else if (n == 0) {

                    /* connection closed by client */

                    printf("client[%d] closed connection\n", i);

                    Close(sockfd);

                    client[i].fd = -1;

                } else {

                    for (j = 0; j < n; j++)

                        buf[j] = toupper(buf[j]);

                        Writen(sockfd, buf, n);

                }

                if (--nready <= 0)

                    break;              /* no more readable descriptors */

            }

        }

    }

    return 0;

}

client

/* client.c */

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <netinet/in.h>

#include "wrap.h"

 

#define MAXLINE 80

#define SERV_PORT 6666

 

int main(int argc, char *argv[])

{

    struct sockaddr_in servaddr;

    char buf[MAXLINE];

    int sockfd, n;

 

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);

    servaddr.sin_port = htons(SERV_PORT);

 

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    while (fgets(buf, MAXLINE, stdin) != NULL) {

        Write(sockfd, buf, strlen(buf));

        n = Read(sockfd, buf, MAXLINE);

        if (n == 0)

            printf("the other side has been closed.\n");

        else

            Write(STDOUT_FILENO, buf, n);

    }

    Close(sockfd);

    return 0;

}

ppoll

GNU定义了ppoll（非POSIX标准），可以支持设置信号屏蔽字，大家可参考poll模型自行实现C/S。

 

#define _GNU_SOURCE /* See feature_test_macros(7) */

#include <poll.h>

int ppoll(struct pollfd *fds, nfds_t nfds,

           const struct timespec *timeout_ts, const sigset_t *sigmask);

epoll

epoll是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率，因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。

目前epell是linux大规模并发网络程序中的热门首选模型。

epoll除了提供select/poll那种IO事件的电平触发（Level Triggered）外，还提供了边沿触发（Edge Triggered），这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提高应用程序效率。

可以使用cat命令查看一个进程可以打开的socket描述符上限。

    cat /proc/sys/fs/file-max

如有需要，可以通过修改配置文件的方式修改该上限值。

    sudo vi /etc/security/limits.conf

    在文件尾部写入以下配置,soft软限制，hard硬限制。如下图所示。

    * soft nofile 65536

    * hard nofile 100000

基础API

  1. 创建一个epoll句柄，参数size用来告诉内核监听的文件描述符的个数，跟内存大小有关。

    #include <sys/epoll.h>

    int epoll_create(int size)      size：监听数目

  1. 控制某个epoll监控的文件描述符上的事件：注册、修改、删除。

    #include <sys/epoll.h>

    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

        epfd：  为epoll_creat的句柄

        op：    表示动作，用3个宏来表示：

            EPOLL_CTL_ADD (注册新的fd到epfd)，

            EPOLL_CTL_MOD (修改已经注册的fd的监听事件)，

            EPOLL_CTL_DEL (从epfd删除一个fd)；

        event： 告诉内核需要监听的事件

 

        struct epoll_event {

            __uint32_t events; /* Epoll events */

            epoll_data_t data; /* User data variable */

        };

        typedef union epoll_data {

            void *ptr;

            int fd;

            uint32_t u32;

            uint64_t u64;

        } epoll_data_t;

 

        EPOLLIN ：  表示对应的文件描述符可以读（包括对端SOCKET正常关闭）

        EPOLLOUT：  表示对应的文件描述符可以写

        EPOLLPRI：  表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）

        EPOLLERR：  表示对应的文件描述符发生错误

        EPOLLHUP：  表示对应的文件描述符被挂断；

        EPOLLET：   将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)而言的

        EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里

  1. 等待所监控文件描述符上有事件的产生，类似于select()调用。

    #include <sys/epoll.h>

    int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)

        events：    用来存内核得到事件的集合，

        maxevents： 告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，

        timeout：   是超时时间

            -1： 阻塞

            0： 立即返回，非阻塞

            >0： 指定毫秒

        返回值： 成功返回有多少文件描述符就绪，时间到时返回0，出错返回-1

server

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <sys/epoll.h>

#include <errno.h>

#include "wrap.h"

 

#define MAXLINE 80

#define SERV_PORT 6666

#define OPEN_MAX 1024

 

int main(int argc, char *argv[])

{

    int i, j, maxi, listenfd, connfd, sockfd;

    int nready, efd, res;

    ssize_t n;

    char buf[MAXLINE], str[INET_ADDRSTRLEN];

    socklen_t clilen;

    int client[OPEN_MAX];

    struct sockaddr_in cliaddr, servaddr;

    struct epoll_event tep, ep[OPEN_MAX];

 

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    servaddr.sin_port = htons(SERV_PORT);

 

    Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));

 

    Listen(listenfd, 20);

 

    for (i = 0; i < OPEN_MAX; i++)

        client[i] = -1;

    maxi = -1;

 

    efd = epoll_create(OPEN_MAX);

    if (efd == -1)

        perr_exit("epoll_create");

 

    tep.events = EPOLLIN; tep.data.fd = listenfd;

 

    res = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep);

    if (res == -1)

        perr_exit("epoll_ctl");

 

    while (1) {

        nready = epoll_wait(efd, ep, OPEN_MAX, -1); /* 阻塞监听 */

        if (nready == -1)

            perr_exit("epoll_wait");

 

        for (i = 0; i < nready; i++) {

            if (!(ep[i].events & EPOLLIN))

                continue;

            if (ep[i].data.fd == listenfd) {

                clilen = sizeof(cliaddr);

                connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);

                printf("received from %s at PORT %d\n",

                        inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),

                        ntohs(cliaddr.sin_port));

                for (j = 0; j < OPEN_MAX; j++) {

                    if (client[j] < 0) {

                        client[j] = connfd; /* save descriptor */

                        break;

                    }

                }

 

                if (j == OPEN_MAX)

                    perr_exit("too many clients");

                if (j > maxi)

                    maxi = j;       /* max index in client[] array */

 

                tep.events = EPOLLIN;

                tep.data.fd = connfd;

                res = epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &tep);

                if (res == -1)

                    perr_exit("epoll_ctl");

            } else {

                sockfd = ep[i].data.fd;

                n = Read(sockfd, buf, MAXLINE);

                if (n == 0) {

                    for (j = 0; j <= maxi; j++) {

                        if (client[j] == sockfd) {

                            client[j] = -1;

                            break;

                        }

                    }

                    res = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL);

                    if (res == -1)

                        perr_exit("epoll_ctl");

 

                    Close(sockfd);

                    printf("client[%d] closed connection\n", j);

                } else {

                    for (j = 0; j < n; j++)

                        buf[j] = toupper(buf[j]);

                    Writen(sockfd, buf, n);

                }

            }

        }

    }

    close(listenfd);

    close(efd);

    return 0;

}

client

/* client.c */

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <netinet/in.h>

#include "wrap.h"

 

#define MAXLINE 80

#define SERV_PORT 6666

 

int main(int argc, char *argv[])

{

    struct sockaddr_in servaddr;

    char buf[MAXLINE];

    int sockfd, n;

 

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);

    servaddr.sin_port = htons(SERV_PORT);

 

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    while (fgets(buf, MAXLINE, stdin) != NULL) {

        Write(sockfd, buf, strlen(buf));

        n = Read(sockfd, buf, MAXLINE);

        if (n == 0)

            printf("the other side has been closed.\n");

        else

            Write(STDOUT_FILENO, buf, n);

    }

 

    Close(sockfd);

    return 0;

}

epoll进阶

事件模型

EPOLL事件有两种模型：

Edge Triggered (ET) 边缘触发只有数据到来才触发，不管缓存区中是否还有数据。

Level Triggered (LT) 水平触发只要有数据都会触发。

思考如下步骤：

  1. 假定我们已经把一个用来从管道中读取数据的文件描述符(RFD)添加到epoll描述符。
  2. 管道的另一端写入了2KB的数据
  3. 调用epoll_wait，并且它会返回RFD，说明它已经准备好读取操作
  4. 读取1KB的数据
  5. 调用epoll_wait……

在这个过程中，有两种工作模式：

ET模式

ET模式即Edge Triggered工作模式。

如果我们在第1步将RFD添加到epoll描述符的时候使用了EPOLLET标志，那么在第5步调用epoll_wait之后将有可能会挂起，因为剩余的数据还存在于文件的输入缓冲区内，而且数据发出端还在等待一个针对已经发出数据的反馈信息。只有在监视的文件句柄上发生了某个事件的时候 ET 工作模式才会汇报事件。因此在第5步的时候，调用者可能会放弃等待仍在存在于文件输入缓冲区内的剩余数据。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。最好以下面的方式调用ET模式的epoll接口，在后面会介绍避免可能的缺陷。

  1. 基于非阻塞文件句柄
  2. 只有当read或者write返回EAGAIN(非阻塞读，暂时无数据)时才需要挂起、等待。但这并不是说每次read时都需要循环读，直到读到产生一个EAGAIN才认为此次事件处理完成，当read返回的读到的数据长度小于请求的数据长度时，就可以确定此时缓冲中已没有数据了，也就可以认为此事读事件已处理完成。

LT模式

LT模式即Level Triggered工作模式。

与ET模式不同的是，以LT方式调用epoll接口的时候，它就相当于一个速度比较快的poll，无论后面的数据是否被使用。

LT(level triggered)：LT是缺省的工作方式，并且同时支持block和no-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表。

ET(edge-triggered)：ET是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知。请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(only once).

实例一：

基于管道epoll ET触发模式

 

#include <stdio.h>

#include <stdlib.h>

#include <sys/epoll.h>

#include <errno.h>

#include <unistd.h>

 

#define MAXLINE 10

 

int main(int argc, char *argv[])

{

    int efd, i;

    int pfd[2];

    pid_t pid;

    char buf[MAXLINE], ch = 'a';

 

    pipe(pfd);

    pid = fork();

    if (pid == 0) {

        close(pfd[0]);

        while (1) {

            for (i = 0; i < MAXLINE/2; i++)

                buf[i] = ch;

            buf[i-1] = '\n';

            ch++;

 

            for (; i < MAXLINE; i++)

                buf[i] = ch;

            buf[i-1] = '\n';

            ch++;

 

            write(pfd[1], buf, sizeof(buf));

            sleep(2);

        }

        close(pfd[1]);

    } else if (pid > 0) {

        struct epoll_event event;

        struct epoll_event resevent[10];

        int res, len;

        close(pfd[1]);

 

        efd = epoll_create(10);

        /* event.events = EPOLLIN; */

        event.events = EPOLLIN | EPOLLET;       /* ET 边沿触发 ，默认是水平触发 */

        event.data.fd = pfd[0];

    epoll_ctl(efd, EPOLL_CTL_ADD, pfd[0], &event);

 

        while (1) {

            res = epoll_wait(efd, resevent, 10, -1);

            printf("res %d\n", res);

            if (resevent[0].data.fd == pfd[0]) {

                len = read(pfd[0], buf, MAXLINE/2);

                write(STDOUT_FILENO, buf, len);

            }

        }

        close(pfd[0]);

        close(efd);

    } else {

        perror("fork");

        exit(-1);

    }

    return 0;

}

实例二：

基于网络C/S模型的epoll ET触发模式

server

/* server.c */

#include <stdio.h>

#include <string.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <signal.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <sys/epoll.h>

#include <unistd.h>

 

#define MAXLINE 10

#define SERV_PORT 8080

 

int main(void)

{

    struct sockaddr_in servaddr, cliaddr;

    socklen_t cliaddr_len;

    int listenfd, connfd;

    char buf[MAXLINE];

    char str[INET_ADDRSTRLEN];

    int i, efd;

 

    listenfd = socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    servaddr.sin_port = htons(SERV_PORT);

 

    bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    listen(listenfd, 20);

 

    struct epoll_event event;

    struct epoll_event resevent[10];

    int res, len;

    efd = epoll_create(10);

    event.events = EPOLLIN | EPOLLET;       /* ET 边沿触发 ，默认是水平触发 */

 

    printf("Accepting connections ...\n");

    cliaddr_len = sizeof(cliaddr);

    connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

    printf("received from %s at PORT %d\n",

            inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),

            ntohs(cliaddr.sin_port));

 

    event.data.fd = connfd;

    epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &event);

 

    while (1) {

        res = epoll_wait(efd, resevent, 10, -1);

        printf("res %d\n", res);

        if (resevent[0].data.fd == connfd) {

            len = read(connfd, buf, MAXLINE/2);

            write(STDOUT_FILENO, buf, len);

        }

    }

    return 0;

}

client

/* client.c */

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <netinet/in.h>

 

#define MAXLINE 10

#define SERV_PORT 8080

 

int main(int argc, char *argv[])

{

    struct sockaddr_in servaddr;

    char buf[MAXLINE];

    int sockfd, i;

    char ch = 'a';

 

    sockfd = socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);

    servaddr.sin_port = htons(SERV_PORT);

 

    connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    while (1) {

        for (i = 0; i < MAXLINE/2; i++)

            buf[i] = ch;

        buf[i-1] = '\n';

        ch++;

 

        for (; i < MAXLINE; i++)

            buf[i] = ch;

        buf[i-1] = '\n';

        ch++;

 

        write(sockfd, buf, sizeof(buf));

        sleep(10);

    }

    Close(sockfd);

    return 0;

}

实例三：

基于网络C/S非阻塞模型的epoll ET触发模式

server

/* server.c */

#include <stdio.h>

#include <string.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <sys/epoll.h>

#include <unistd.h>

#include <fcntl.h>

 

#define MAXLINE 10

#define SERV_PORT 8080

 

int main(void)

{

    struct sockaddr_in servaddr, cliaddr;

    socklen_t cliaddr_len;

    int listenfd, connfd;

    char buf[MAXLINE];

    char str[INET_ADDRSTRLEN];

    int i, efd, flag;

 

    listenfd = socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    servaddr.sin_port = htons(SERV_PORT);

 

    bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    listen(listenfd, 20);

 

    struct epoll_event event;

    struct epoll_event resevent[10];

    int res, len;

    efd = epoll_create(10);

    /* event.events = EPOLLIN; */

    event.events = EPOLLIN | EPOLLET;       /* ET 边沿触发 ，默认是水平触发 */

 

    printf("Accepting connections ...\n");

    cliaddr_len = sizeof(cliaddr);

    connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

    printf("received from %s at PORT %d\n",

            inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),

            ntohs(cliaddr.sin_port));

 

    flag = fcntl(connfd, F_GETFL);

    flag |= O_NONBLOCK;

    fcntl(connfd, F_SETFL, flag);

    event.data.fd = connfd;

    epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &event);

 

    while (1) {

        printf("epoll_wait begin\n");

        res = epoll_wait(efd, resevent, 10, -1);

        printf("epoll_wait end res %d\n", res);

 

        if (resevent[0].data.fd == connfd) {

            while ((len = read(connfd, buf, MAXLINE/2)) > 0)

                write(STDOUT_FILENO, buf, len);

        }

    }

    return 0;

}

client

/* client.c */

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <netinet/in.h>

 

#define MAXLINE 10

#define SERV_PORT 8080

 

int main(int argc, char *argv[])

{

    struct sockaddr_in servaddr;

    char buf[MAXLINE];

    int sockfd, i;

    char ch = 'a';

 

    sockfd = socket(AF_INET, SOCK_STREAM, 0);

 

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);

    servaddr.sin_port = htons(SERV_PORT);

 

    connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

 

    while (1) {

        for (i = 0; i < MAXLINE/2; i++)

            buf[i] = ch;

        buf[i-1] = '\n';

        ch++;

 

        for (; i < MAXLINE; i++)

            buf[i] = ch;

        buf[i-1] = '\n';

        ch++;

 

        write(sockfd, buf, sizeof(buf));

        sleep(10);

    }

    Close(sockfd);

    return 0;

}

线程池并发服务器

  1. 预先创建阻塞于accept多线程，使用互斥锁上锁保护accept
  2. 预先创建多线程，由主线程调用accept
liuhehe321
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络编程套接字（Socket编程）
weixin_64015613的博客
07-04 1733
网络套接字编程，Java Socket 编程
Linux 高并发服务器
weixin_47897030的博客
08-07 139
Web服务器要为用户提供服务，必须以某种方式，工作在某个套接字上。一般Web服务器在处理用户请求时，一般有如下三种方式可选择：多进程方式、多线程方式、异步方式。
100万并发连接服务器笔记之Java Netty处理1M连接会怎么样
热门推荐
Mr__fang的专栏
05-14 1万+
转载:http://www.blogjava.net/yongboy/archive/2013/05/13/399203.html 前言 每一种该语言在某些极限情况下的表现一般都不太一样，那么我常用的Java语言，在达到100万个并发连接情况下，会怎么样呢，有些好奇，更有些期盼。 这次使用经常使用的顺手的netty NIO框架（netty-3.6.5.Final），封装的很好，接口很
多进程并发服务器与多线程并发服务器
最新发布
qq_43264167的博客
01-26 797
无论是多进程并发服务器还是多线程并发服务器，都有各自的缺点。常见的还是多路IO复用服务器。
【Linux网络编程】高并发服务器 socket+epoll封装 服务器/客户端举例
持续学习，持续进步！
06-29 3850
本文主要介绍高并发服务器设计，socke+epoll封装，以及相关代码示例说明
qt c++ 高并发服务器 源码
02-07
qt c++ 高并发服务器 源码 编译通过
Linux多线程高并发服务器
03-10
在IT行业中，Linux多线程高并发服务器设计是构建高性能网络服务的核心技术之一。这种设计模式主要用于处理大量的并发连接请求，充分利用系统资源，提供高效稳定的服务。以下将详细阐述相关知识点： 1. **多线程**：...
高并发高性能服务器
08-13
在IT领域，构建高并发高性能服务器是至关重要的技术挑战，特别是在大数据时代，处理大量用户请求、实时数据交换以及保持高效的服务响应成为系统设计的核心。本资料包提供的"高并发高性能服务器"源码提供了深入理解这...
webserver(1)_linux高并发服务器_源码
10-04
在IT领域，尤其是在服务器开发和运维中，"Linux高并发服务器"是一个至关重要的主题。这里的“webserver(1)_linux高并发服务器_源码”是一个针对该主题的实践项目，它采用Preactor模式并利用了Linux的epoll LT模型来...
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
09-27
在Linux 系统下面用C 语言实现的高并发服务器的代码，具体用到了Epoll，线程池，数据库连接池。 具体可以看下连接http://blog.csdn.net/wuyuxing24/article/details/48758927
非常全面的高性能高并发服务器架构解决方案
07-25
非常全面的高性能高并发服务器架构解决方案
套接字编程
辉哥仔
04-27 221
套接字地址结构 大多数套接字哈桉树都需要一个指向套接字地址结构的指针作为参数。每个协议族都定义它自己的套接字地址结构。这些结构的名字均以sockaddr_开头，并以对应每个协议族的唯一后缀结尾。 IPv4套接字地址结构 IPv4套接字地址结构以sockaddr_in命名，定义在<netinet/in.h>头文件中。 struct in_addr{ in_addr_t ...
Linux系统下的文件I/O操作函数
qq_43570177的博客
12-23 522
Linux系统下的文件I/O操作函数
Day 46 Linux深入学习
m0_60247706的博客
10-17 132
Linux深入学习
【C/C++服务器开发】文件，文件描述符，I/O多路复用，select / poll / epoll 详解
qq_41854911的博客
01-07 1984
文章目录一、前言1.文件的概念2.文件描述符和文件指针文件描述符文件描述符和文件指针的区别文件描述符太多了怎么办二、I/O多路复用1.I/O多路复用的由来不要打电话给我，有需要我会打给你I/O多路复用，I/O multiplexing2.I/O多路复用在Linux上的实现方法I/O多路复用三剑客select：初出茅庐poll：小有所成epoll：独步天下总结3.select、poll、epoll详解1.select详解2.poll详解3.epoll详解三、网络事件库 一、前言 在了解I/O多路复用之前，我们
Socket套接字编程
niukeming的博客
09-18 1万+
前天面试了环信公司，在面试的时候，感觉面试官很亲切，临走的时候叫我回去再把TCP和UDP网络编程在看看，并且给他发过去，我知道现在的水平确实还有很大提升的空间，我也会一直不断的学习，加强自身的知识水平建设。 （1）基于UDP协议的socket套接字编程 UDP协议是非链接的协议，它不与对方建立连接，而是直接把要发送的数据发送给对方。所以UDP协议适用于一次传输数据量很少，对可靠性要求不高的应用场...
套接字函数及其理解
Guo_guo
09-18 3714
1、套接字主要函数介绍：   套接字函数通常封装在Ws2_32.dll动态连接库中，头文件是winsock2.h,因此用户需要引用头文件和链接库       #include “winsock.h”  //引用头文件       #pragma comment(lib,”ws2_32.lib”)  //链接库文件 此外，使用套接库函数前需要初始化套接字，使用函数WSASta
C++的TCP套接字编程的基本步骤
实践求真知
04-14 3945
一服务端编程步骤 1创建服务端套接字（使用socket）。 2绑定套接字到一个IP地址和端口上（使用bind）。 3将套接字设置为监听模式等待连接请求（使用函数listen），这个套接字就是监听套接字。 4请求到来时，接受连接请求，返回一个新的对此次连接的套接字（accept）。 5用返回新的套接字和客户端进行通信，即发送或接收数据（使用函数send或recv），通信结束就关...
高并发服务器编程之多进程并发服务器
Apollon_krj的博客
02-27 7291
同类基础博客： 基于Linux的SOCKET编程之TCP半双工Client-Server聊天程序 基于Linux的Socket编程之TCP全双工Server-Client聊天程序 一、多进程并发分析：特点： 占用资源大，但是一个进程挂了不会影响另一个。这与多线程刚好相反，多线程服务器不稳定。分析： 父进程循环accept，当父进程接收到链接请求之后，立即fork出一个新的子进程去处理通信
高性能高并发服务器架构探讨与实践
"高性能高并发服务器架构" 在构建高性能高并发服务器架构时，开发者和运维人员需要关注多个关键点以确保系统的稳定性和可扩展性。以下是对这些关键点的详细阐述： 1. 数据库切分与优化：面对大量用户和高并发请求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值