前置知识：
下文如果有地方产生疑惑，可以点击下方链接查看
socket：socket的概念和常用函数介绍-CSDN博客
使用socket编程来实现一个简单的C/S模型（TCP协议）-CSDN博客
1.多进程并发服务器
使用多进程并发服务器时要考虑以下几点：
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;
struct sockaddr_in cliaddr; // Accept传出参数，客户端的地址结构
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)); //将地质结构空间清0
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); //父进程只进行监听等待其它客户端来连接
//因此关闭掉与客户端连接的套接字connfd，让子进程去和客户端进行数据交换
//这里不能用while(1) waitpid去回收子进程，只能用信号捕捉，才不会导致僵尸进程和影响下一个客户端的连接
} else
perr_exit("fork");
}
Close(listenfd);
return 0;
}父子进程共享监听与连接的套接字，子进程关闭监听套接字，只是监听套接字被引用数--，而非监听套接字==0（等于0，释放空间），所以不影响客户端继续监听新客户端连接
只是让父进程关闭掉与客户端进行的连接后的套接字(Accept)，关闭掉子进程中的监听套接字(Listen)，让创建出来的子进程只与客户端进行通信，让服务器专门去监听是否有用户来申请连接服务器
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;
}
2.多线程并发服务器
在使用线程模型开发服务器时需考虑以下问题：
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
// 定义一个结构体，将accept返回的套接字connfd和客户端的地址结构捆绑起来
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]; // #define INET_ADDRSTRLEN 16 可用"[+d"查看
/* 可以在创建线程前设置线程创建属性,设为分离态,哪种效率高呢？ */
pthread_detach(pthread_self()); //如果要求获取到子线程的线程退出状态，就得用join
//或者父线程再创建一个线程专门去获取兄弟线程的退出状态并返回给主线程
while (1) {
n = Read(ts->connfd, buf, MAXLINE); //读客户端
if (n == 0) {
printf("the other side has been closed.\n");
break; //跳出循环，关闭cfd
}
printf("received from %s at PORT %d\n",
inet_ntop(AF_INET, &(*ts).cliaddr.sin_addr, str, sizeof(str)),
ntohs((*ts).cliaddr.sin_port)); //打印客户端信息：IP和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)); //地址结构清0
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); //指定本地任意IP
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]);
// 将存储的套接字和客户端的地址结构的结构体传给多线程服务器对应的线程，等该线程结束时便于关闭套接字
// 采用传址的方式是可以的，因为线程中对ts是只读的，并且这里不能传值操作，因为void *是16字节的，而ts这个结构体是20字节了，强转会丢失数据
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;
}
3.多路I/O转接服务器
多路IO转接服务器也叫做多任务IO服务器。该类服务器实现的主旨思想是，不再由应用程序自己监视客户端连接，取而代之由内核替应用程序监视文件。让aceept不用阻塞等待，一有请求就连接返回套接字
主要使用的方法有三种
借助内核，select来监听，客户端连接、数据通信事件
3.1 select函数
多个客户端同时请求连接时，服务器来不及处理，尚未accept的客户处理等待连接状态，listen处于监听状态 -- 阻塞方式的服务器对于多个客户端同时请求的连接，accept只能挨个去处理客户端，创建套接字连接绑定地址结构，其余客户端阻塞等待连接，并且监听和连接都是服务器来做的。listen监听到客户端请求的连接(老板看到客人来) --> accept创建套接字(客人决定入住，但没房间，客人暂时离开，老板立马去整理好房间) --> 阻塞等待三次握手完成与client1连接(房间整理完等待客户回来入住) --> listen空闲迎接下一位 --> accept创建套接字(如果client1还没连接好还在阻塞中，这里的accept也没法调用，若client1连接好，没有新的client请求连接，accept会阻塞等待)
而通过select，监听让select来，服务器转交给select的listen套接字一收到client1的请求连接，就立马通知服务器调用accept创建套接字cfd转给select，让seclet负责client1与cfd1的连接；此时client2也来请求连接，select通知server调用accept创建cfd2直接返回给select与client2连接，accept不需要等待client1连接完成后才能被调用。（老板lfd看到客人client来，立马吩咐手下去整理好房间cfd，告诉老板整理好的房间号，客人可以立马入住，不需要等待）
把监听客户端的读写和连接全丢给内核select做，server只需要负责响应select的要求，如创建套接字
也不能说是同时处理多个服务器的连接请求，只是不用像原始的那样等accept阻塞完连接上服务器才能去处理下一个client的连接请求(不是多进程或是多线程情况下)，同时还能像多进程那样继续去处理连接上的客户端的读请求事件等
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，因为此参数会告诉内核检测前多少个文件描述符的状态
文件描述符表(0、1、2、....6)，传入6+1，检测7前面的文件描述符的状态
参2、3、4皆为传入传出参数，对应着文件描述符的三种事件
readfds：监控有读数据到达文件描述符集合，传入传出参数 (对应文件描述符的读事件) -- 服务器要读的事件
writefds：监控写数据到达文件描述符集合，传入传出参数 (写事件) -- 服务器要写给客户端的
exceptfds：监控异常发生达文件描述符集合,如带外数据到达异常，传入传出参数 (异常事件)
传入的是要监听的文件描述符(监听条件)，等函数结束时传出的则是实际有事件发生的(满足监听条件，就绪的fd)
因此如果一些文件描述符对应的事件，比如异常exceptfds，并没有的发生，不需要监听，那该参数可以传NULL
注意：类型是位图(二进制)，如果要监听5的读事件是否就绪，就将传入的位图中的第5位翻转为1
timeout：定时阻塞监控时间，3种情况
1.NULL，永远等下去
2.设置timeval，等待固定时间
3.设置timeval里时间均为0，检查描述字后立即返回，轮询
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};
返回值：
返回监听的文件描述符事件发生的总个数，注意是否包含listen请求连接的事件
select监控参数1+1之前所有文件描述符的状态，因此肯定包含了lfd的客户端请求连接事件
void FD_ZERO(fd_set *set); //把文件描述符集合里所有位清0
fd_set readfds;
FD_ZERO(&readfds);
void FD_SET(int fd, fd_set *set); //把文件描述符集合里fd位置1
FD_SET(4,&readfds); FD_SET(5,&readfds);
int FD_ISSET(int fd, fd_set *set); //测试文件描述符集合里fd是否置1
FD_ISSET(4,&readfds); //存在返回1，不存在返回0
void FD_CLR(int fd, fd_set *set); //把文件描述符集合里fd位清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, listenfd, connfd, sockfd;
int maxfd = 0; //记录最大的文件描述符
int nready;
fd_set rset, allset; //rset 读事件文件描述符集合 allset用来暂存，防止了rset传入后传出覆盖了原先的集合的发生
ssize_t n;
char buf[MAXLINE];
char str[INET_ADDRSTRLEN]; /* #define INET_ADDRSTRLEN 16 */
socklen_t cliaddr_len;
struct sockaddr_in cliaddr, servaddr;
int maxi;
int client[FD_SETSIZE]; /* FD_SETSIZE 默认为 1024 */
//client数组是为了提高效率，文件描述符0、1、2默认被占用，rset中下标为0、1、2的位图为0，而3为监听描述符
//假设client1已经占用了4，4-1022的文件描述符被管道或者文件占用，这时候client2申请连接，占用1023
//那么rset中仅仅只有3、4、1023有用，当client有读请求时，不采用数组存储的方式的话用rset去遍历，就需要遍历1024遍
//用client[]存储请求连接客户端的文件描述符，maxi存储最后一个文件描述符的下标，这时候循环对象就为client[]
//仅仅存储了客户端和文件描述符，只有2个，处理读请求时只需要循环2次即可
//client[i]利用FD_ISSET看是否在rset中，是的话就可以直接处理文件描述符的读请求
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[]的下标,初始值指向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); //返回请求事件发生的个数，如果传出的rset包含lfd，说明还有客户请求连接
//如果传出参数rset中不包含lfd，说明只有读事件请求满足，直接处理rset中对应客户端的大小写转换
if (nready < 0)
perr_exit("select error");
//预先判断select监控到的rset中的lfd是否有事件，有就先处理
//lfd为1，有客户端请求连接，通知server创建套接字，if结尾检查是否仅仅只有请求连接事件
if (FD_ISSET(listenfd, &rset)) { /* new client connection */
cliaddr_len = sizeof(cliaddr);
connfd = Accept(listenfd, (struct sockaddr*)&cliaddr, &cliaddr_len); // 不会阻塞等待，交给select
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) //该条件，如：最大是7，但4关闭连接了，此时新来的client就被放到了4，最大文件描述符还是7
maxfd = connfd; /* select第一个参数需要 */
if (i > maxi)
maxi = i; /* 更新client[]最大下标值 */
if (--nready == 0)
continue; /* 如果没有更多的就绪文件描述符继续回到上面select阻塞监听,
负责处理未处理完的就绪文件描述符 */
//处理完客户端的请求连接，--nready==0，说明只有客户端请求连接事件发生，没有读事件请求
//回到for进入下一个循环，select阻塞监听等待新事件的请求
}
for (i = 0; i <= maxi; i++) { /* 检测哪个clients 有数据就绪 ，循环对象是client，而不是sret了*/
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) //新客户连接请求中nready已经被--了，剩下的都是读事件的客户端文件描述符 -- 用于通信的，对其进行处理
//每处理完一个文件描述符的读事件，就做--操作，直到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替代当前进程的阻塞信号集，调用返回后还原原有阻塞信号集优缺点
缺点：
监听上限受文件描述符限制，最大为1024。
检测满足条件的fd，需要自己添加数据等，添加业务逻辑提高小，提高了编码难度
(参2、参3、参4传出的数据类型本质是二进制位图，下标0-1023就对应着文件描述符，存在就为1，不存在就为0，出现除了3和1023是listen和client，其它文件描述符都被占用的情况下，要去遍历处理client的请求就需要循环1024次，比较麻烦，需要自己添加逻辑)
参2、参3、参4是传入传出参数，因此会覆盖原来的数据，需要取容器暂存起来才能保证数据不丢失
优点：
跨平台，windows、linux、macOS、Unix、类Unix、mips
当某一路IO处于阻塞态时，select监视到其他的IO有读或写，就可以让其他路的IO读写；如果没有select,当有一路IO阻塞，其他的IO即使可以读写，也无法进行。
3.2 poll
#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
fds：监听的文件描述符[数组]
struct pollfd {
int fd; /* 文件描述符 */
short events; /* 监控的事件 */
short revents; /* 监控事件中满足条件返回的事件 */
// 传入时，给0；如果满足对应事件的话返回非0
}; // 传进和传出分开了
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。
相较于select而言，poll的优势：
1. 传入、传出事件分离。无需每次调用时，重新设定监听事件。
2. 文件描述符上限，可突破1024限制。能监控的最大上限数可使用配置文件调整。
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 = POLLIN; /* 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 & POLLIN) { /* 有客户端链接请求 */
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 = POLLIN; /* 设置刚刚返回的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 & POLLIN) {
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);优缺点
优点：
自带数组结构，可以将监听事件集合和返回事件集合分离
拓展监听上限，超出1023限制
缺点：
不能跨平台，只限于linux
无法直接定位满足监听事件文件描述符，编码难度较大
3.3 epoll
epoll是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率，因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。
目前epoll是linux大规模并发网络程序中的热门首选模型。
epoll除了提供select/poll那种IO事件的电平触发（Level Triggered）外，还提供了边沿触发（Edge Triggered），这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提高应用程序效率。
可以使用cat命令查看一个进程可以打开的socket描述符上限。
cat /proc/sys/fs/file-max
当前计算机所能打开的最大文件个数。受硬件影响
ulimit -a
当前用户下的进程，默认打开文件描述符个数，缺省为1024
如有需要，可以通过修改配置文件的方式修改该上限值。
sudo vi /etc/security/limits.conf
在文件尾部写入以下配置,soft软限制，hard硬限制。如下图所示。
* soft nofile 65536 -->设置默认值，可直接借助命令修改
* hard nofile 100000 -->命令修改上限
基础API
epoll_create
1. 创建一个epoll句柄，参数size用来告诉内核监听的文件描述符的个数，跟内存大小有关。
#include <sys/epoll.h>
int epoll_create(int size)
size：创建的红黑树的监听节点数目（仅供内核参考）
返回值：成功：非负文件描述符；失败：-1，设置相应的errnoepoll_ctl
2. 控制某个epoll监控的文件描述符上的事件：注册、修改、删除。
#include <sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
1.epfd： 为epoll_creat函数的返回值
2.op： 对该监听红黑树所做的操作，用3个宏来表示：
EPOLL_CTL_ADD (注册新的fd到epfd)，
EPOLL_CTL_MOD (修改已经注册的fd的监听事件)，
EPOLL_CTL_DEL (从epfd删除一个fd)；
3.fd：待监听的文件描述fd
4.event：告诉内核需要监听的事件(结构体的地址)，如果
如果监听的事件满足就会被存在epoll_wait的传出参数events数组当中
struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
epoll_event结构体成员：
data：联合体(共用体)
typedef union epoll_data {
void *ptr; //epoll反应堆模型，可以在某种程度上取代fd
int fd; //对应监听事件的fd，和参数3fd一样的
uint32_t u32;
uint64_t u64;
} epoll_data_t;
events：表示监听的文件描述符的状态(读、写、异常事件)
EPOLLIN ： 表示对应的文件描述符可以读（包括对端SOCKET正常关闭）
EPOLLOUT： 表示对应的文件描述符可以写
EPOLLPRI： 表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）
EPOLLERR： 表示对应的文件描述符发生错误
EPOLLHUP： 表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)而言的
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里
返回值：成功：0；失败：-1，设置相应的errno
epoll_wait
3. 等待所监控文件描述符上有事件的产生，类似于select()调用。
#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
events：用来存内核得到事件满足(满足监听事件)的文件描述符所在的struct epoll_event的集合，可简单看作数组。
maxevents：告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size
参2events数组元素的上限
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]; //可以不需要，因为epoll_wait传出的event数组中有都是满足条件的客户端的fd
struct sockaddr_in cliaddr, servaddr;
// tep：epoll_ctl参数(传入时取地址)，ep[]：epoll_wait参数
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); //创建epoll模型，efd指向红黑树根节点
if (efd == -1)
perr_exit("epoll_create");
tep.events = EPOLLIN;
tep.data.fd = listenfd; //指定lfd的监听事件为“读”
//efd，添加节点，要添加节点的fd，fd的struct epoll_event*结构体(包含了要监听fd的事件)
res = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep); //将lfd已经对应的结构设置到树上，efd可找到该树
if (res == -1)
perr_exit("epoll_ctl");
while (1) {
//epoll为server阻塞监听事件，ep为struct epoll_event类型数组，传出监听条件满足(已经就绪的客户端)的client的struct epoll_event数据
//OPEN_MAX为数组容量，-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) { //判断满足事件的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); //从efd树中去掉，关闭与该客户端的链接
if (res == -1)
perr_exit("epoll_ctl");
Close(sockfd);
printf("client[%d] closed connection\n", j);
}
else if (n < 0) {
//出错
perror("read n < 0 error");
Close（sockfd);
}
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;
}
扫一扫
1909
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
