声明
- 在Android系统中经常会遇到一些系统原理性的问题，在此专栏中集中来讨论下。
- Android系统中很多地方都采用了I/O多路复用的机制，为了引出I/O多路复用机制，先来分析多路并发情况下的C/S模型。
- 此篇参考一些博客和书籍，代码基于Android 7.1.1，不方便逐一列出，仅供学习、知识分享。
- 此篇代码下载：多路并发情况下的C/S模型实例
1 概述
假设有一个将 INET 套接字用作 C/S 模型。如果想让一个Server端与多个 Client端通信，那么每个Server端 和 Client端都需要 INET 套接字。如果多客户端同时连接服务器端，那服务器端如何处理多客户端的服务请求呢？ C/S模型通常有三种处理方式：多进程、多线程、I/O 多路复用。
2 多路并发情况下的C/S模型
通常利用多进程或多线程的方式进行进程或线程与多个客户端通信的操作，并处理服务请求。这种方式比较直观，但由于要使用IPC 或互斥量对进程及线程进行同步，所以进程或线程数量越多，编程就会变得越复杂。另外，生成进程和线程需要很多资源。
2.1 多进程模型
2.1.1 多进程模型框架
多进程模型接收到来自客户端的连接请求后，调用 fork() 函数生成处理连接请求的新进程。fork() 通常在 Linux 环境下复制一个程序本身，然后同时处理多个操作。下图为 Server 端的多进程模型。Server 端进程对各 Client 端的连接请求生成新的 worker 进程进行处理。worker 进程并行处理Client 的请求。
多进程模型是 Heavy-Weight 模型，通过 fork 生成新进程后，需要在新的内存区域生成并复制父进程内的所有数据结构。调用 fork() 函数生成进程会消耗很多系统资源，多进程也需要在相互独立的内存空间中运行，所以需要进程间的 IPC，程序也会随之变得更加复杂。
使用多进程并发服务器时要考虑以下几点：
- 父进程最大文件描述个数(父进程中需要关闭accept返回的新文件描述符)
- 系统内创建进程个数(与内存大小相关)
- 进程创建过多是否降低整体服务性能(进程调度)
2.1.2 多进程模型代码实例
2.1.2.1 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 <ctype.h>
#include <unistd.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 8888
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;
//设置SIGCHLD信号的处理函数,用来回收执行结束子进程
struct sigaction newact;
newact.sa_handler = do_sigchild;
sigemptyset(&newact.sa_mask);
newact.sa_flags = 0;
sigaction(SIGCHLD, &newact, NULL);
//创建服务端socket
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);
//绑定服务端的socket
Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
//设置监听socket，最大监听数为：20
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) {
//关闭子进程中继承来的服务端监听socket
Close(listenfd);
//在while循环中处理客户端的请求
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);
}
//关闭客户端连接socket
Close(connfd);
return 0;
//进入父进程
} else if (pid > 0) {
//关闭客户端连接socket
Close(connfd);
} else
perr_exit("fork");
}
Close(listenfd);
return 0;
}
2.1.2.2 Client端代码
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 8888
int main(int argc, char *argv[])
{
struct sockaddr_in servaddr;
char buf[MAXLINE];
int sockfd, n;
//创建客户端中的socket，其为服务端在客户端中代表
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));
//通过sockfd向服务端发送请求，并接收返回信息
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);
}
//通信结束后，关闭socket
Close(sockfd);
return 0;
}
2.2 多线程模型
2.2.1 多线程模型框架
多线程是Light-Weight 模型，不生成新进程，而是共享进程的大部分资源，只需要线程的数据结构（局部变量、保存寄存器的空间、栈、PC 等），这样就解决了多进程模型存在的问题。使用多线程时，多线程的生成及上下文切换消耗较少，速度又快，且不需要其他 IPC 即可通过共享资源进行通信。最后，在CPU多核环境中各线程可以在不同Core中并行，所以对CPU多核环境而言非常有用。
下图的是Server 端进程的多线程模型。每当Server 端进程收到来自Client 端的连接请求时，都会生成新线程，或使用线程池中等待的线程，以处理各Client 端的服务请求。
多线程模型也存在缺点：一个线程的死亡会对该线程所在的整个进程产生很大影响，很难推测各线程中哪个先运行，也就很难进行调试。
在使用线程模型开发服务器时需考虑以下问题：
- 调整进程内最大文件描述符上限
- 线程如有共享数据，考虑线程同步
- 服务在客户端线程退出时，退出处理（退出值，分离态）
- 系统负载，随着链接客户端增加，导致其它线程不能及时得到CPU
2.2.2 多线程模型代码实例
2.2.2.1 Server端代码
/* server.c */
#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 8888
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循环中处理客户端的请求
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);
return (void *)0;
}
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];
//创建服务端socket
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);
//绑定服务端的socket
Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
//设置监听socket，最大监听数为：20
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;
}
2.2.2.2 Client端代码
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 8888
int main(int argc, char *argv[])
{
struct sockaddr_in servaddr;
char buf[MAXLINE];
int sockfd, n;
//创建客户端中的socket，其为服务端在客户端中代表
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));
//通过sockfd向服务端发送请求，并接收返回信息
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);
}
//通信结束后，关闭socket
Close(sockfd);
return 0;
}
2.3 I/O多路复用模型
2.3.1 I/O多路复用模型框架
I/O 多路复用模型利用单一进程或线程为多客户端提供服务。I/O 多路复用模型中最具代表性的是使用 select() 函数。
select() 函数对处理多个 IO 事件的文件描述符的集合 (fd_set) 进行监控。文件描述符集中如果特定文件描述符发生 I/O 事件( 读、写、错误等)，文件描述符集中相应的文件描述符的位会发生变化。select() 函数感应到文件描述符位的变化后，返回等待状态，并执行相应文件描述符的读取及写人操作。select() 函数默认提示 I/O 事件的发生，但不会告知文件描述符中发生的是第几个 I/O 事件。因此需要执行循环，找到文件描述符集的第几个文件描述符位中发生了 I/O 事件。下图是 I/O 多路复用的概念。I/O 多路复用处理多客户端进程的服务请求，不生成新进程，其主旨思想是，不再由应用程序自己监视客户端连接，取而代之由内核替应用程序监视文件。
I/O多路复用模型的实现可以有三种方法：
- select
- poll
- epoll
2.3.2 I/O多路复用模型代码实例
2.3.2.1 使用 select 实现的 Server 端代码
- select能监听的文件描述符个数受限于FD_SETSIZE，一般为1024，单纯改变进程打开的文件描述符个数并不能改变select监听文件个数
- 解决1024以下客户端时使用 select 是很合适的，但如果链接客户端过多，select 采用的是轮询模型，会大大降低服务器响应效率，不应在select上投入更多精力
#include <sys/select.h>
/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
/**
nfds: 监控的文件描述符集里最大文件描述符加1，因为此参数会告诉内核检测前多少个文件描述符的状态
readfds： 监控有读数据到达文件描述符集合，传入传出参数
writefds： 监控写数据到达文件描述符集合，传入传出参数
exceptfds： 监控异常发生达文件描述符集合,如带外数据到达异常，传入传出参数
timeout： 定时阻塞监控时间，3种情况
1.NULL，永远等下去
2.设置timeval，等待固定时间
3.设置timeval里时间均为0，检查描述字后立即返回，轮询
*/
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
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.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <ctype.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; /* rset 读事件文件描述符集合 allset用来暂存 */
char buf[MAXLINE];
char str[INET_ADDRSTRLEN]; /* #define INET_ADDRSTRLEN 16 */
socklen_t cliaddr_len;
struct sockaddr_in cliaddr, servaddr;
//创建服务端socket
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);
//绑定服务端的socket
Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
//设置监听socket，最大监听数为：20
Listen(listenfd, 20); /* 默认最大128 */
maxfd = listenfd; /* 起初 listenfd 即为最大文件描述符 */
maxi = -1; /* 将来用作client[]的下标, 初始值指向0个元素之前下标位置 */
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)) { /* 说明有新的客户端链接请求 */
cliaddr_len = sizeof(cliaddr);
connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len); /* Accept 不会阻塞 */
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[]中没有使用的位置 */
client[i] = connfd; /* 保存accept返回的文件描述符到client[]里 */
break;
}
}
/* 达到select能监控的文件个数上限 1024 */
if (i == FD_SETSIZE) {
fputs("too many clients\n", stderr);
exit(1);
}
FD_SET(connfd, &allset); /* 向监控文件描述符集合allset添加新的文件描述符connfd */
if (connfd > maxfd)
maxfd = connfd; /* select第一个参数需要 */
if (i > maxi)
maxi = i; /* 保证maxi存的总是client[]最后一个元素下标 */
if (--nready == 0)
continue; /* 如果没有更多的就绪文件描述符继续回到上面select阻塞监听,
负责处理未处理完的就绪文件描述符 */
}
//检测哪个 client 有数据就绪了
for (i = 0; i <= maxi; i++) {
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; /* 跳出for, 但还在while中 */
}
}
}
Close(listenfd);
return 0;
}
2.3.2.2 使用 select 实现的 Client 端代码
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.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[])
{
struct sockaddr_in servaddr;
char buf[MAXLINE];
int sockfd, n;
//创建客户端中的socket，其为服务端在客户端中代表
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));
//通过sockfd向服务端发送请求，并接收返回信息
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);
}
//通信结束后，关闭socket
Close(sockfd);
return 0;
}
2.3.2.3 使用 poll 实现的 Server 端代码
#include <poll.h>
/**
POLLIN 普通或带外优先数据可读，即POLLRDNORM | POLLRDBAND
POLLRDNORM 数据可读
POLLRDBAND 优先级带数据可读
POLLPRI 高优先级可读数据
POLLOUT 普通或带外数据可写
POLLWRNORM 数据可写
POLLWRBAND 优先级带数据可写
POLLERR 发生错误
POLLHUP 发生挂起
POLLNVAL 描述字不是一个打开的文件
nfds 监控数组中有多少文件描述符需要被监控
timeout 毫秒级等待
-1：阻塞等，#define INFTIM -1
0：立即返回，不阻塞进程
>0：等待指定毫秒数，如当前系统时间精度不够毫秒，向上取值
*/
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
/**
如果不再监控某个文件描述符时，可以把pollfd中，fd设置为-1，poll不再监控此pollfd，
下次返回时，把revents设置为0。
*/
struct pollfd {
int fd; /* 文件描述符 */
short events; /* 监控的事件 */
short revents; /* 监控事件中满足条件返回的事件 */
};
/* 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; //接收poll返回值, 记录满足监听事件的fd个数
ssize_t n;
char buf[MAXLINE], str[INET_ADDRSTRLEN];
socklen_t clilen;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr, servaddr;
//创建服务端socket
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);
//绑定服务端的socket
Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
//设置监听socket，最大监听数为：20
Listen(listenfd, 20);
client[0].fd = listenfd; /* 要监听的第一个文件描述符 存入client[0] */
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) { /* listenfd有读事件就绪 */
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen); /* 接收客户端请求 Accept 不会阻塞 */
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阻塞 */
}
// 检测client[]
for (i = 1; i <= maxi; i++) { /* 前面的if没满足,说明没有listenfd满足. 检测client[] 看是那个connfd就绪 */
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; /* poll中不监控该文件描述符,直接置为-1即可,不用像select中那样移除 */
} 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;
}
2.3.2.4 使用 poll 实现的 Client 端代码
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.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[])
{
struct sockaddr_in servaddr;
char buf[MAXLINE];
int sockfd, n;
//创建客户端中的socket，其为服务端在客户端中代表
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));
//通过sockfd向服务端发送请求，并接收返回信息
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);
}
//通信结束后，关闭socket
Close(sockfd);
return 0;
}
2.3.2.5 使用 epoll 实现的 Server 端代码
epoll 是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率：
- 因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合
- 另一点原因是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核I/O事件异步唤醒而加入Ready队列的描述符集合就行了
目前epoll是linux大规模并发网络程序中的热门首选模型。除了提供 select/poll 那种I/O事件的电平触发（Level Triggered）外，还提供了边沿触发（Edge Triggered），这就使得用户空间程序有可能缓存I/O状态，减少 epoll_wait/epoll_pwait的调用，提高应用程序效率。
epoll的一些基础API：
- 创建一个epoll句柄，参数size用来告诉内核监听的文件描述符的个数，跟内存大小有关。
#include <sys/epoll.h> int epoll_create(int size) //size：监听数目 - 控制某个epoll监控的文件描述符上的事件：注册、修改、删除。
#include <sys/epoll.h> /** epfd： 为epoll_creat的句柄 op： 表示动作，用3个宏来表示： EPOLL_CTL_ADD (注册新的fd到epfd)， EPOLL_CTL_MOD (修改已经注册的fd的监听事件)， EPOLL_CTL_DEL (从epfd删除一个fd)； event： 告诉内核需要监听的事件 */ int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) /** EPOLLIN ： 表示对应的文件描述符可以读（包括对端SOCKET正常关闭） EPOLLOUT： 表示对应的文件描述符可以写 EPOLLPRI： 表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来） EPOLLERR： 表示对应的文件描述符发生错误 EPOLLHUP： 表示对应的文件描述符被挂断； EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)而言的 EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里 */ 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; - 等待所监控文件描述符上有事件的产生，类似于select()调用。
#include <sys/epoll.h> /** events： 用来存内核得到事件的集合， maxevents： 告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size， timeout： 是超时时间 -1： 阻塞 0： 立即返回，非阻塞 >0： 指定毫秒 返回值： 成功返回有多少文件描述符就绪，时间到时返回0，出错返回-1 */ int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
/*server.c*/
#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 <ctype.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];
//创建服务端socket
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);
//绑定服务端的socket
Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
//设置监听socket，最大监听数为：20
Listen(listenfd, 20);
for (i = 0; i < OPEN_MAX; i++)
client[i] = -1;
maxi = -1;
efd = epoll_create(OPEN_MAX); //创建epoll模型, efd指向红黑树根节点
if (efd == -1)
perr_exit("epoll_create");
tep.events = EPOLLIN; tep.data.fd = listenfd; //指定lfd的监听时间为"读"
res = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep); //将lfd及对应的结构体设置到树上,efd可找到该树
if (res == -1)
perr_exit("epoll_ctl");
while (1) {
nready = epoll_wait(efd, ep, OPEN_MAX, -1); /*epoll为server阻塞监听事件, ep为struct epoll_event类型数组, 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) {//判断满足事件的fd是不是lfd
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 {//不是lfd,
sockfd = ep[i].data.fd;
n = Read(sockfd, buf, MAXLINE);
if (n == 0) {//读到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;
}
2.3.2.6 使用 epoll 实现的 Client 端代码
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.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[])
{
struct sockaddr_in servaddr;
char buf[MAXLINE];
int sockfd, n;
//创建客户端中的socket，其为服务端在客户端中代表
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));
//通过sockfd向服务端发送请求，并接收返回信息
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);
}
//通信结束后，关闭socket
Close(sockfd);
return 0;
}
2.4 三种模型优缺点对比
510
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
