1.select函数实现多路IO转接服务器
select函数原型：包含在头文件<sys/time.h>，<sys/types.h>和<unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);作用：确定一个或多个套接字的状态等待指向并同步
参数nfds：就是服务器的套接字(监听的所有文件描述符中，最大文件描述符+1)
参数readfds：监听读状态（读 文件描述符监听集合）
参数writefds：监听写状态（写 文件描述符监听集合）
参数exceptfds：监听异常状态（异常 文件描述符监听集合）
参数timeout：超时参数
>0：表述设置监听超时时长
NULL：阻塞监听
0：表示非阻塞监听，轮询
返回值：
>0：所有监听集合中，满足对应事件的总数
0：没有满足监听条件的文件描述符
-1：出错
需要配合使用的有如下四个函数
void FD_CLR(int fd, fd_set *set);//将一个文件描述符从监听集合中移除
int FD_ISSET(int fd, fd_set *set);//判断一个文件描述符是否在监听集合中，存在返回1，否则返回0
void FD_SET(int fd, fd_set *set);//将待监听的文件描述符，添加到监听集合中
void FD_ZERO(fd_set *set);//清空一个文件描述符集合select模型的优缺点：
缺点：监听上限受文件描述符限制，最大1024
检测满足条件的fd，需要自己添加业务逻辑提高效率，提高了编码难度
优点：可以跨平台
select多路IO服务器代码实例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <ctype.h>
#include "wrap.h"
#define SER_PORT 9990
int main(int argc, char* argv[])
{
int lfd = Socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in serv_addr;
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(SER_PORT);
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
Bind(lfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
Listen(lfd, 128);
//进行IO多路转接
fd_set allSock;//全部的sock
int ret;//select返回值存放
int maxfd = lfd;//最大文件描述符
fd_set allread;//读socket集合
struct sockaddr_in client_addr;//存放客户端信息的结构体对象
bzero(&client_addr, sizeof(client_addr));
int connfd;//保存客户端的id
int i = 0;
char buf[1024] = {0};
FD_ZERO(&allSock);
FD_SET(lfd, &allSock);//先存放服务器的sock
while(1)
{
allread = allSock;
ret = select(maxfd+1, &allread, NULL, NULL, NULL);
if(ret < 0)//表示没有客户端发来消息
{
perr_exit("select error");
}
if(FD_ISSET(lfd, &allread))//如果服务器socket存在监听中则表示有可以和端连接
{
int client_len = sizeof(client_addr);
connfd = Accept(lfd, (struct sockaddr*)&client_addr, &client_len);
//把客户端socket加入到监听集合中
FD_SET(connfd, &allSock);
//判断最大文件描述符是否有变化
if(maxfd<connfd)
{
maxfd = connfd;
}
if(ret == 1)//表示响应的客户端只有一个，那就是表示只需要执行接受连
//接的操作，下面的语句就不需要用执行
{
continue;
}
}
for(i = lfd+1; i <= maxfd; i++)
{
if(FD_ISSET(i, &allread))
{
int n = read(i, buf, 1024);
//判断客户端的状态
if(n == 0)//表示客户端下线
{
close(i);//关闭客户端
FD_CLR(i, &allSock);//从集合中移除
}else if(n < 0)//表示读取出错
{
perr_exit("read error");
}
for(int j = 0;j < n; j++)
{
buf[j] = toupper(buf[j]);
}
write(i, buf, n);
write(STDOUT_FILENO, buf, n);
}
}
}
Close(lfd);
return 0;
}
2.poll函数实现的多路IO转接服务器
poll函数原型：包含在头文件<poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
参数解释：
参数fds：监听文件描述符的数组
参数nfds：监听数组的实际有效个数
参数timeout：超时时长
返回值：返回满足对应监听事件的文件描述符总个数
//需要使用到的结构体 该结构体作为poll函数的第一个参数
struct pollfd {
int fd; /* 待监听的文件描述符 */
short events; /* 待监听的文件描述符对应的监听事件 */
short revents; /* 传入时给0，如果满足对应事件的话，返回非0，表示返回的监听事件集合 */
};优缺点：
优点：自带数组结构，可以将监听事件集合和返回事件集合分离，可以扩展监听数量的上限，
缺点：不能跨平台，无法直接定位满足监听事件的文件描述符，编码难度大
poll实现的多路IO转接服务器代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>
#include <errno.h>
#include <ctype.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 8000
#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;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
int opt = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
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, 128);
client[0].fd = listenfd; /* 要监听的第一个文件描述符 存入client[0]*/
client[0].events = POLLIN; /* listenfd监听普通读事件 */
for (i = 1; i < OPEN_MAX; i++)
client[i].fd = -1; /* 用-1初始化client[]里剩下元素 0也是文件描述符,不能用 */
maxi = 0; /* client[]数组有效元素中最大元素下标 */
for ( ; ; ) {
nready = poll(client, maxi+1, -1); /* 阻塞监听是否有客户端链接请求 */
if (client[0].revents & POLLIN) { /* 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 = POLLIN; /* 设置刚刚返回的connfd,监控读事件 */
if (i > maxi)
maxi = i; /* 更新client[]中最大元素下标 */
if (--nready <= 0)
continue; /* 没有更多就绪事件时,继续回到poll阻塞 */
}
for (i = 1; i <= maxi; i++) { /* 前面的if没满足,说明没有listenfd满足. 检测client[] 看是那个connfd就绪 */
if ((sockfd = client[i].fd) < 0)
continue;
if (client[i].revents & POLLIN) {
if ((n = Read(sockfd, buf, MAXLINE)) < 0) {
/* connection reset by client */
if (errno == ECONNRESET) { /* 收到RST标志 */
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) { /* 说明客户端先关闭链接 */
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;
}
}
}
return 0;
}
3.epoll模型实现的多路IO转接服务器
epoll的设计模式
epoll本质上是一个平衡二叉树
epoll函数的工作方式：
epoll的两种工作方式：1.水平触发（LT）2.边缘触发（ET）
LT模式：若就绪的事件一次没有处理完要做的事件，就会一直去处理。即就会将没有处理完的事件继续放回到就绪队列之中（即那个内核中的链表），一直进行处理(缓冲区剩余未读尽的数据会导致 epoll_wait 返回)
ET模式：就绪的事件只能处理一次，若没有处理完会在下次的其它事件就绪时再进行处理。而若以后再也没有就绪的事件，那么剩余的那部分数据也会随之而丢，高效模式，只支持非阻塞模式 (缓冲区剩余未读尽的数据不会导致 epoll_wait 返回)
由此可见：ET模式的效率比LT模式的效率要高很多。只是如果使用ET模式，就要保证每次进行数据处理时，要将其处理完，不能造成数据丢失，这样对编写代码的人要求就比较高。
注意：ET模式只支持非阻塞的读写：为了保证数据的完整性。
1.函数的解析
1.epoll_crl函数：包含在头文件<sys/epoll.h>
作用：用于操作epoll函数所生成的实例，
函数原型：
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
参数解释：
参数epfd：epoll_create函数返回的epoll实例的句柄
参数op：表示需要执行的操作，有添加，删除，修改
可选选项：
1.EPOLL_CTL_ADD：在文件描述符epfd所引用的epoll实例上注册目标文件描述符fd，并将事件
事件与内部文件链接到fd。
2.EPOLL_CTL_MOD：更改与目标文件描述符fd相关联的事件。
3.EPOLL_CTL_DEL：从epfd引用的epoll实例中删除（注销）目标文件描述符fd。
该事件将被忽略，并且可以为NULL
参数fd：需要添加，修改，删除的socket文件描述符
参数event：需要epoll监视的fd对应的事件类型(本质上是struct epoll_event结构体对象的指针)
返回值：成功时，epoll_ctl（）返回零。发生错误时，epoll_ctl（）返回-1并正确设置了errno
使用到的结构体
typedef union epoll_data {//这是一个联合体
void *ptr;
int fd; //对应监听的事件socket
uint32_t u32;
uint64_t u64;
} epoll_data_t;
struct epoll_event {
uint32_t events; /* epoll监视的事件类型 */
epoll_data_t data; /* 用户数据 */
};
events成员的选项宏：
1.EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
2.EPOLLOUT：表示对应的文件描述符可以写；
3.EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
4.EPOLLERR：表示对应的文件描述符发生错误； EPOLLHUP：表示对应的文件描述符被挂断；
5.EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
6.EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，
需要再次把这个socket加入到EPOLL队列里。2.epoll_create函数：包含在头文件<sys/epoll.h>
函数原型：
int epoll_create(int size);
函数解释：
该函数生成一个epoll专用的文件描述符。它其实是在内核申请一空间，
用来存放你想关注的socket fd上是否发生以及发生了什么事件。
size就是你在这个epoll fd上能关注的最大socket数3.epoll_wait函数
函数原型：
int epoll_wait(int epfd, struct epoll_event *events,
int maxevents, int timeout);
作用：该函数用于轮询I/O事件的发生
参数解释：
1.epfd:由epoll_create 生成的epoll专用的文件描述符；
2.epoll_event:用于回传待处理事件的数组；
3.maxevents:每次能处理的事件总数
4.timeout:等待I/O事件发生的超时值(单位我也不太清楚)；-1相当于阻塞，
· 0相当于非阻塞，大于0表示设置的超时时间
返回值：返回发生事件的soket数量2.实现epoll服务器的步骤
1.创建服务器socket，使用到socket函数
2.绑定ip地址和端口号，使用到bind函数
3.监听服务器socket， 使用到listen函数
4.创建树根，使用到函数 epoll_create函数
5.给服务器socket绑定事件，使用到结构体 struct epoll_event
6.把服务器socket挂上树等待监听，使用到函数 epoll_ctl
7.开始监听树上的socket事件，使用到epoll_wait函数
epoll实现的多路IO转接服务器代码实例
#include<stdio.h>
#include<stdlib.h>
#include<strings.h>
#include<ctype.h>
#include<sys/epoll.h>
#include<arpa/inet.h>
#include<unistd.h>
int main()
{
//1.创建socket
int lfd = socket(AF_INET, SOCK_STREAM, 0);
if(lfd == -1)
{
perror("socket error");
exit(-1);
}
//绑定端口号和ip
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(11100);
serv.sin_addr.s_addr = htonl(INADDR_ANY);
int ret = bind(lfd, (struct sockaddr*)&serv, sizeof(serv));
if(ret == -1)
{
perror("bind error");
exit(-1);
}
//3.监听
ret = listen(lfd, 128);
if(ret == -1)
{
perror("listen error");
exit(-1);
}
//4.创建一个树根
int base = epoll_create(1024);
if(base == -1)
{
perror("base error");
exit(-1);
}
struct epoll_event tep;//作为epoll_ctl函数的参数,用来绑定服务器socket的epoll_event的事件
struct epoll_event op[128];//作为epoll_wait函数的参数，保存所有事件
//5.给服务器lfd绑定事件
tep.events = EPOLLIN;//绑定读事件
tep.data.fd = lfd;//需要绑定的套接字
//6.把事件挂到树根上进行监听
ret = epoll_ctl(base, EPOLL_CTL_ADD, lfd, &tep);
if(ret == -1)
{
perror("epoll_ctl error");
exit(-1);
}
while(1)
{
//7.开始监听树上的socket，返回有事件的socket数量，存放入到op数组中
int nready = epoll_wait(base, op, 1024, 0);
//处理epoll_wait返回值的情况
if(nready == -1)
{
perror("epoll_wait error");
exit(-1);
}
int i = 0;
for(i = 0;i < nready;i ++)
{
int client_fd = op[i].data.fd;
//判断是否为读事件
if(!op[i].events & EPOLLIN)
{
continue;
}
//如果是服务器socket，处理链接
if(op[i].data.fd == lfd)
{
int cld = accept(lfd, NULL, NULL);
//绑定事件类型
tep.events = EPOLLIN;
tep.data.fd = cld;
//把客户端socket挂上树
ret = epoll_ctl(base, EPOLL_CTL_ADD, cld, &tep);
if(ret == -1)
{
perror("accept epoll_ctl error");
exit(-1);
}
printf("[%d] 客户端连接成功\n", cld);
}
else//表示有读事件
{
char buf[1024] = {0};
//把内容读取出来
int num = read(op[i].data.fd, buf, sizeof(buf));
if(num == -1)
{
perror("read error");
exit(-1);
}
//表示客户端关闭
else if(num == 0)
{
//把该客户端从树上摘下来
ret = epoll_ctl(base, EPOLL_CTL_DEL, op[i].data.fd, NULL);
if(ret == -1)
{
printf("从树上摘除失败\n");
}
close(client_fd);
printf("[%d]client 客户端关闭\n", client_fd);
}
else//把内容写回去
{
for(i = 0;i < num; i++)
{
buf[i] = toupper(buf[i]);
}
//把内容发送回去
write(client_fd, buf, num);
write(STDOUT_FILENO, buf, num);
}
}
}
}
close(lfd);
close(base);
return 0;
}
epoll两种工作模型实现代码
#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 9000
int main(void)
{
struct sockaddr_in servaddr, cliaddr;
socklen_t cliaddr_len;
int listenfd, connfd;
char buf[MAXLINE];
char str[INET_ADDRSTRLEN];
int 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 边沿触发 */
//event.events = EPOLLIN; /* 默认 LT 水平触发 */
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); //readn(500)
write(STDOUT_FILENO, buf, len);
}
}
return 0;
}