linux 多线程 select,Linux多线程编程----IO【select、poll、epoll】

最新推荐文章于 2023-08-25 18:46:23 发布

SquaringK

最新推荐文章于 2023-08-25 18:46:23 发布

阅读量412

点赞数

文章标签： linux 多线程 select

IO操作多速度就下降

IO数据的读和写

IO的完成必须等到读事件(如磁盘拷贝每次要从磁盘查找数据) 和写事件 (允许写如写太快写满就要马上阻塞)的就绪

IO是否高效：主要看一次IO中等的时间的比例的多少 (等的时间比例越少越高效)

就像钓鱼分两步：1 等 2 钓 (评价钓鱼技术高效是等的时间少钓的次数多)

5中IO模型

1 阻塞式IO：等的时候自己等，数据搬迁也是由自己来操作， IO事件就绪时自己处理。期间什么也不做

2 非阻塞IO ：(轮询方式) 期间做自己的事情

3 信号驱动： (信号事件驱动)期间做自己的事情(IO请求事件条件满足时来通知我，我再来处理，期间我自己做自己的事情)

4 IO复用：把多个IO事件托管给IO复用，一次等待多个 IO操作，有一个满足就来通知我，我自己就去处理。等的比重小，IO操作的频率变大。

Linux中常见有select、poll、epoll

Windows中有 select、IOCP

5 异步IO：不用自己来处理，只是自己将IO的操作分配给别人

1-4是同步IO ，(自己亲自处理，只是等待的方式不同) 5 是异步IO (自己不亲自处理，交给别人去处理)

高级IO

文件描述符重定向

以前将1号文件描述符关闭 (1号是标准输出)再将一个新的文件打开这是printf则将内容打印到这个文件中这样就实现了文件描述符的重定向

代码：#include

#include

int main()

{

char buf[1024];

read(0, buf, sizeof(buf) - 1);

close(1);

int fd = open("./log", O_CREAT|O_RDWR, 0666);

printf("%d--------%s",fd, buf); // 原本是打印到标准输出现在是文件fd

return 0;

}

运行：[bozi@localhost dup]$ ./dup

asdcxz

[bozi@localhost dup]$ cat log

1--------asdcxz

太low

现在用 dup 就可以实现文件描述符的重定向int dup(int oldfd);

int dup2(int oldfd, int newfd);

int dup3(int oldfd, int newfd, int flags);

dup2() makes newfd be the copy of oldfd, closing newfd first if neces- 如果有必要拷贝(这里拷贝是拷贝文件描述符里面的内容而不是文件描述符)前关闭 newfd的文件描述符

sary, but note the following: 例如将5(oldfd新打开的文件描述符)重定向到1(newfd标准输出) 如果一之前打开着关闭1

* If oldfd is not a valid file descriptor, then the call fails, and

newfd is not closed.

* If oldfd is a valid file descriptor, and newfd has the same value as

oldfd, then dup2() does nothing, and returns newfd.

重定向不光是重定向文件描述符还可以重定向网络这样发数据就直接发送到网络

dup练习代码：#include

#include

int main()

{

int fd = open("./log", O_CREAT | O_RDWR,0666);

if (fd

{

perror("open");

return 1;

}

close(1);// 关闭标准输出

int new_fd = dup(fd);

if (new_fd == -1)

{

perror("dup");

return 2;

}

close(fd);

char buf[1024];

while (1)

{

memset(buf, '\0', sizeof(buf));

fgets(buf, sizeof(buf), stdin);

if (strncmp("quit", buf, 4) == 0)

{

break;

}

printf("%s", buf);// 打到文件中

fflush(stdout);

}

close(new_fd);

return 0;

}

运行:[bozi@localhost dup]$ ./dup

hello world

i am here

come on

quit

[bozi@localhost dup]$ cat log

hello world

i am here

come on

dup2 练习代码：练习代码：

#include

int main()

{

int fd = open("./log", O_CREAT|O_RDWR);

if (fd

{

perror("open");

return fd;

}

close(1);

int ret = dup2(fd, 1); // fd->1

char buf[1024];

while (1)

{

memset(buf, '\0', sizeof(buf));

fgets(buf, sizeof(buf) - 1, stdin);

if (strncmp(buf, "quit", 4) == 0)

{

break;

}

printf("%s", buf);

fflush(stdout);

}

close(fd);

return 0;

}

运行：[bozi@localhost dup]$ ./dup2

hello everybody

nihao sun

quit

[bozi@localhost dup]$ cat log

hello everybody

nihao sun

pipe/socketepair 创建双向通信管道

练习代码：#include

#include

int main()

{

int sv[2];// 文件描述符

if (socketpair(AF_LOCAL, SOCK_STREAM, 0, sv)

{

perror("socketpair");

return 0;

}

pid_t id = fork();

if (id == 0)

{

// child

close(sv[0]);

const char *msg = "I am child";

char buf[1024];

while (1)

{

write(sv[1], msg, strlen(msg));

memset(buf, 0, sizeof(buf));

ssize_t _s = read(sv[1], buf, sizeof(buf) - 1);

if (_s > 0)

{

// buf[_s] = '\0';

printf("%d father->child: %s\n",_s, buf);

}

else if (_s == 0)

{

printf("child wait father...\n");

}

else

{

exit(1);

}

sleep(2);

}

else

{

//father

close(sv[1]);// 只要和 child 不一样就行

char buf[1024];

while (1)

{

memset(buf, 0, sizeof(buf));

read(sv[0], buf, sizeof(buf) - 1);

printf("child -> father: %s\n", buf);

strcpy(buf, "I am father");

int sz = write(sv[0], buf, strlen(buf));

//int sz = write(sv[0], buf, sizeof(buf) - 1); // error sizeof(buf)

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

}

运行：[bozi@localhost test_20160806]$ ./my_socketpair

child -> father: I am child

11 father->child: I am father

child -> father: I am child

11 father->child: I am father

child -> father: I am child

11 father->child: I am father

child -> father: I am child

11 father->child: I am father

select

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

fd_set *exceptfds, struct timeval *timeout);

第一个参数是输入型参数其他既是输入型又是输出型参数

nfds表示当前最大的文件描述符+1

fd_set *readfds 调用时表示只关心文件描述符集中的读事件返回时表示该文件描述符集中有哪些读事件就绪

fd_set *writefds 调用时表示只关心写事件

fd_set *exceptfds 只关心异常事件

struct timeval *timeout); 设置超时时间因为是输入输出型的如果没超时返回的是剩余的时间如果超时返回的是0

void FD_CLR(int fd, fd_set *set);

int FD_ISSET(int fd, fd_set *set);

void FD_SET(int fd, fd_set *set);

void FD_ZERO(fd_set *set);

练习代码1：

/* select 检测标准输入输出*/#include

#include

int main()

{

fd_set read_set;

fd_set write_set;

FD_ZERO(&read_set);

FD_ZERO(&write_set);

int read_fd = 0;

int write_fd = 1;

int max_fd = 2;

char buf[1024];

while (1)

{

struct timeval timeout= {3,0};

FD_SET(read_fd, &read_set);

FD_SET(write_fd, &write_set);

int ret = select(max_fd + 1, &read_set, &write_set, NULL, &timeout);// 除了第一个参数后面4个都是输入-输出型参数

switch(ret)

{

case -1:

perror("select");

return 1;

case 0:

printf("select timeout");

break;

default:

{

if (FD_ISSET(read_fd,& read_set ))

{

memset(buf, '\0', sizeof(buf));

gets(buf);

if (!strncmp(buf, "quit", 4))

{

return 0;

}

printf("read_fd: %s\n", buf);

}

if (FD_ISSET(write_fd, &write_set))

{

strcpy(buf, "output buffer is ok");

puts(buf);

sleep(3);

}

return 0;

}

运行：[bozi@localhost test_20160807]$ ./select_1

output buffer is ok

zai

read_fd: zai

output buffer is ok

练习代码2：

/* 利用select 编写网络服务器 */#include

#include

#include /* See NOTES */

#include

#define _PORT_ 9999

#define _MAX_SIZE_ 10

#define _BACK_LOG_ 5

#define _BUF_SIZE_ 1024

int fd_arr[_MAX_SIZE_];

int max_fd = 0;

static void init_fd_arr()

{

int i =0;

for (; i

{

fd_arr[i] = -1;

}

static int add_fd_arr(int fd)

{

int i = 0;

for (; i

{

if (fd_arr[i] == -1)

{

fd_arr[i] = fd;

return 0;

}

return -1;

}

static int remove_fd_arr(int fd)

{

int i = 0;

for (; i

{

if (fd_arr[i] == fd)

{

fd_arr[i] = -1;

return 0;

}

return -1;

}

static void reload_fd_set(fd_set *fd_setp)

{

int i = 0;

for (; i

{

if (fd_arr[i] != -1)

{

FD_SET(fd_arr[i], fd_setp);

if (fd_arr[i] > max_fd)

{

max_fd = fd_arr[i];

}

static void print_msg(int i , char buf[])

{

printf("fd : %d, msg: %s\n", i , buf);

}

int select_server()

{

struct sockaddr_in server;

struct sockaddr_in client;

fd_set fds;

int fd = socket(AF_INET, SOCK_STREAM, 0);

if (fd

{

perror("socket");

return 1;

}

printf("create socket success\n");

int yes = 1;

setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes ,sizeof(int));// 允许IP地址复用

bzero(&server, sizeof(server));

server.sin_family = AF_INET;

server.sin_port = htons(_PORT_);

server.sin_addr.s_addr = htonl(INADDR_ANY);

if (bind(fd, (struct sockaddr*)&server, sizeof(server))

{

perror("bind");

return 2;

}

printf("bind socket success\0");

init_fd_arr();

add_fd_arr(fd);

FD_ZERO(&fds);

if (listen(fd, _BACK_LOG_)

{

perror("listen error");

return 3;

}

printf("listen socket success\n");

while (1)

{

// 由于 select fds是输入-输出型参数完了值会被改变所以每次从arr中重新加载

reload_fd_set(&fds);

struct timeval timeout = {30, 0};

switch(select(max_fd + 1, &fds/*read*/,NULL, NULL, &timeout ))

{

case -1:

printf("select error, quit\n");

return 4;

case 0:

printf("select timeout, continue wait...\n");

break;

default:

{

int index = 0;

for (; index

{

if (index == 0 && fd_arr[index] != -1 && FD_ISSET(fd_arr[index], &fds))

{

socklen_t len = sizeof(client);

bzero(&client, len);

int new_fd = accept(fd_arr[index], (struct sockaddr*)&client,&len );

// 有新的连接

if (new_fd != -1)

{

printf("get a new request!\n");

// 添加到arr中

if (-1 == add_fd_arr(new_fd))

{

perror("fd arr is full, close new fd\n");

close(new_fd);

}

continue;

}

if (fd_arr[index] != -1&& FD_ISSET(fd_arr[index], &fds))

{

// 有客户端发送消息

char buf[_BUF_SIZE_];

memset(buf, '\0', sizeof(buf));

ssize_t size = read(fd_arr[index], buf,sizeof(buf) );

if (size == 0)

{

printf("remote client close\n" );

close(fd_arr[index]);

//printf("%d is close\n", fd_arr[index]);

// 清除 fds中相应的文件描述符

FD_CLR(fd_arr[index], &fds);

remove_fd_arr(fd_arr[index]);

}

else

{

print_msg(fd_arr[index],buf );

}

int main()

{

select_server();

return 0;

}

代码：【客户端】

/* select_2 的客户端*/#include

#include

#include /* See NOTES */

#include

void usage(const char* arg)

{

printf("please enter : %s [IP] [PORT]\n",arg );

}

int select_client(char *ip, int port)

{

int fd = socket(AF_INET, SOCK_STREAM, 0);

if (fd

{

perror("create socket error");

return 1;

}

struct sockaddr_in server;

bzero(&server, sizeof(server));

server.sin_family = AF_INET;

server.sin_addr.s_addr = inet_addr(ip);

server.sin_port = htons(port);

if (connect(fd, (struct sockaddr*)&server, sizeof(server))

{

perror("connect error");

return 2;

}

char buf[1024];

while (1)

{

memset(buf, '\0', sizeof(buf));

printf("please enter: ");

fflush(stdout);

fgets(buf, sizeof(buf) - 1, stdin);

printf("buf is: %s\n", buf);

int ret = send(fd, buf, strlen(buf) + 1, 0);

if (ret

{

perror("send msg error\n");

}

close(fd);

}

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

{

if (argc != 3)

{

usage(argv[0]);

return 44;

}

int port = atoi(argv[2]);

select_client(argv[1],port);

return 0;

}

servers iptables stop 关闭防火墙

poll

输入的文件监听描述符和返回的监听到的事件与select 不同 select 是输入-输出型

poll

不依赖于文件系统，所以他所关心的文件描述符的数量是没有限制的

poll代码：

struct pollfd poll_set[2];

//struct pollfd poll_set[1];

//read

poll_set[0].fd = 0;

poll_set[0].events = POLLIN;

poll_set[0].revents = 0;

// write

poll_set[1].fd = 1;

poll_set[1].events = POLLOUT;

poll_set[1].revents = 0;

int timeout = 3000;

char buf[1024];

while (1)

{

switch(poll(poll_set, 2, timeout))

// switch(poll(poll_set, 1, timeout))

{

case -1:

printf("poll error\n");

return 1;

break;

case 0:

printf("poll timeout\n");

break;

default:

if (poll_set[0].revents & POLLIN)

{

memset(buf, '\0', sizeof(buf));

printf("poll get \n");

fgets(buf, sizeof(buf) - 1, stdin);

printf("msg is: %s\n", buf);

}

if(poll_set[1].revents & POLLOUT)

{

printf("pollout is ok\n");

sleep(1);

}

break;

}

return 0;

}

int main()

{

mypoll();

return 0;

}

运行：[bozi@localhost poll]$ ./poll

pollout is ok

asd

pollout is ok

poll get

msg is: asd

pollout is ok

adasd

epoll

区分： select 和 poll 是在文件描述符之上的不依赖于文件系统的

epoll 是基于文件系统的是占用文件描述符的

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

struct epoll_event *events 输出型参数返回所有监听成功的事件

The struct epoll_event is defined as :

typedef union epoll_data {

void *ptr;

int fd;

uint32_t u32;

uint64_t u64;

} epoll_data_t;

struct epoll_event {

uint32_t events; /* Epoll events */

epoll_data_t data; /* User data variable */

};

代码：#include

#include

#define LISTEN_BACK_LOG 10

// 创建监听套接字

int startup(char* ip, int port)

{

int sock = socket(AF_INET, SOCK_STREAM, 0);

if (sock

{

perror("socket");

exit(1);

}

int op = 1;

setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &op, sizeof(int));

struct sockaddr_in local;

local.sin_family = AF_INET;

local.sin_port = htons(port);

local.sin_addr.s_addr= inet_addr(ip);

if (bind(sock, (struct sockaddr*)&local, sizeof(local))

{

perror("bind");

exit(2);

}

if (listen(sock,LISTEN_BACK_LOG)

{

perror("listen");

exit(3);

}

return sock;

}

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

{

if (argc != 3)

{

printf("please enter: %s [ip] [port]\n", argv[0]);

exit(4);

}

int listen_sock = startup(argv[1], atoi(argv[2]));

// 创建 epoll 句柄事件表

int epfd = epoll_create(101);// 这里数字不固定，100 只是告诉内核预计用100个文件描述符但实际这个参数不起作用只是建议

if (epfd

{

perror("epoll_create");

exit(5);

}

struct epoll_event event;

event.events = EPOLLIN; // 读事件列表

event.data.fd = listen_sock;

// 向事件表中增加事件

epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &event);

struct epoll_event fd_events[100];

int size = sizeof(fd_events)/sizeof(fd_events[0]);

int i = 0;

for (i = 0; i

{

fd_events[i].events = 0;

fd_events[i].data.fd = -1;

}

int nums = 0;

int timeout = 10000;

int done = 0;

while (!done)

{

// 返回就绪的文件个数

nums = epoll_wait(epfd, fd_events, size, timeout);

switch (nums)

{

case 0:

printf("timeout...\n");

break;

case -1:

perror("epoll_wait\n");

exit(6) ;

default:

{

for (i = 0; i

{

int fd = fd_events[i].data.fd;

if ((fd == listen_sock) && (fd_events[i].events & EPOLLIN))

{

// listen socket 有新的连接请求

struct sockaddr_in peer;

socklen_t len = sizeof(peer);

int new_sock = accept(listen_sock, (struct sockaddr*)&peer, &len);

if (new_sock

{

perror("accept");

continue;

}

printf("get a new client, socket->%s:%d\n", inet_ntoa(peer.sin_addr),ntohs(peer.sin_port));

event.events = EPOLLIN;

event.data.fd = new_sock;

// 将new_sock 添加进内核事件表

epoll_ctl(epfd, EPOLL_CTL_ADD,new_sock, &event);

}

else

{

// other socket

// // 读事件满足处理客户端发送的数据

if (fd_events[i].events & EPOLLIN)

{

char buf[1024];

memset(buf, '\0', sizeof(buf));

ssize_t _s = recv(fd, buf, sizeof(buf) - 1, 0);

if (_s > 0)

{

printf("client: %s\n", buf);

event.events = EPOLLOUT;//将fd事件改为写方便服务器给请求的客户端发数据

epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &event);

}

else if (_s == 0)

{

printf("client close...\n");

epoll_ctl(epfd, EPOLL_CTL_DEL,fd,NULL );// 空表示不关心返回值

close(fd);

}

else

{

perror("recv");

continue;

}

else if(fd_events[i].events & EPOLLOUT)

{

// WRITE

char *msg = "HTTP/1.1 200 OK\r\n\r\n

hello ^_^

\r\n";

send(fd, msg, strlen(msg), 0);

//event.events = EPOLLIN;

//epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &event);

epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);

close(fd);

}

else

{

}

break;

}

exit(0);

}

运行：[bozi@localhost epoll]$ ./epoll_IO 127.0.0.1 8888

get a new client, socket->127.0.0.1:59387

client: GET / HTTP/1.1

Host: 127.0.0.1:8888

User-Agent: Mozilla/5.0 (X11; Linux i686; rv:17.0) Gecko/20131029 Firefox/17.0

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3

Accept-Encoding: gzip, deflate

Connection: keep-alive

比较 select、 poll 、epoll的优缺点

(1)为啥多路复用效率高(IO等的时间少，有效工作时间比例大)

(2)多路复用服务器与之前的线程进程的服务器比较至少高 1个数量级

以前多进程，大部分进程都是阻塞状态，等待状态。浪费比较大。

同时多进程占用的空间也比较大。

(3)select

1、select主要是通过3个文件描述符集(类似于位图，用上面的位来记录，有专门的对这些位操作的宏)来记录事件

rdset,wrset,exset分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集合及异常文件描述符的集合。

下面的宏提供了处理这三种描述词组的方式:

FD_CLR(inr fd,fd_set* set)；用来清除描述词组set中相关fd 的位

FD_ISSET(int fd,fd_set *set)；用来测试描述词组set中相关fd 的位是否为真

FD_SET(int fd,fd_set*set)；用来设置描述词组set中相关fd的位

FD_ZERO(fd_set *set)；用来清除描述词组set的全部位

2、可监控文件描述符的个数取决于sizeof(fd_set)的大小，这个是有内核限制的，所以select所能监控的事件个数比较少

3、select的3个文件描述符集是输入-输出型参数，输入时表示要监听的事件，select运行后，3个文件描述符集表示发生的事件，(可以理解为将监听事件相应位为1中发生的发生的事件的位置1，没发生的位置0)，这样下次还要监听这些事件时，就找不到之前的文件描述符集的值了，所以要额外用数组来记录要监听的文件描述符，以便于每次select之前初始化文件描述符集

优点：多路复用的优点(IO等的时间少，有效工作时间比例大)

缺点：(1)每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大

(2)同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大

(3)select支持的文件描述符数量太小了，默认是1024( 使用32个整数的32位，即32*32=1024来标识fd)

(4)poll

1、不同与select使用三个位图来表示三个fdset的方式，poll使用一个 pollfd的指针实现。可以创建struct pollfd的结构体，不再是按照三个位图读、写、异常来存放事件，而是分别设置每个pollfd结构体的事件属性。

struct pollfd

{

int fd; /* File descriptor to poll. */

short int events; /* Types of events poller cares about. */ 监听事件类型常见EPOLLIN 读事件 EPOLLOUT写事件

short int revents; /* Types of events that actually occurred. */ 就绪事件

};

2、pollfd结构包含了要监视的event和发生的event，不再使用select“参数-值”传递的方式。

3、pollfd并没有最大数量限制(但是数量过大后性能也是会下降)。

优点：1、多路复用的优点

2、与select相比没有事件个数的限制，传的是pollfd数组指针，数组大小可以很大

缺点：和select函数一样，poll返回后，需要轮询pollfd来获取就绪的描述符。从上面看，select和poll都需要在返回后，通过遍历文件描述符来获取已经就绪的socket。事实上，同时连接的大量客户端在一时刻可能只有很少的处于就绪状态，因此随着监视的描述符数量的增长，其效率也会线性下降。

(5)epoll(最高效的)

poll的改进版

优点：

1、多路复用的优点

2、支持一个进程打开大数目的socket描述符

与select不同， epoll则没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左右，和机器内存大小有关。

3、IO效率不随FD文件描述符数目增加而线性下降

传统的select/poll另一个致命弱点就是当你拥有一个很大的socket集合，不过由于网络延时，任一时间只有部分的socke是"活跃"的，但是select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是epoll不存在这个问题，它只会对"活跃"的socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback(就绪事件链表)函数实现的。那么，只有"活跃"的socket才会主动的去调用 callback函数，其他idle状态socket则不会，在这点上，epoll实现了一个"伪"AIO，因为这时候推动力在os内核。在一些 benchmark中，如果所有的socket基本上都是活跃的---比如一个高速LAN环境，epoll并不比select/poll有什么效率，相反，如果过多使用epoll_ctl,效率相比还有稍微的下降。但是一旦使用idle connections模拟WAN环境,epoll的效率就远在select/poll之上了。

4、使用mmap加速内核与用户空间的消息传递，避免不必要的内存拷贝

这点实际上涉及到epoll的具体实现了。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。而如果你想我一样从2.5内核就关注epoll的话，一定不会忘记手工 mmap这一步的。

5、内核微调

这一点其实不算epoll的优点了，而是整个linux平台的优点。也许你可以怀疑linux平台，但是你无法回避linux平台赋予你微调内核的能力。比如，内核TCP/IP协议栈使用内存池管理sk_buff结构，那么可以在运行时期动态调整这个内存pool(skb_head_pool)的大小--- 通过echoXXXX>/proc/sys/net/core/hot_list_length完成。再比如listen函数的第2个参数(TCP完成3次握手的数据包队列长度)，也可以根据你平台内存大小动态调整。更甚至在一个数据包面数目巨大但同时每个数据包本身大小却很小的特殊系统上尝试最新的NAPI网卡驱动架构。

缺点：

1、如果在并发量低，socket都比较活跃的情况下，select就不见得比epoll慢了

2、epoll跨平台不好 select linux、windows都支持

epoll 为什么快高效 epoll 红黑树就绪队列

epoll高效的原理，就绪队列和红黑树

将注册的事件插入到红黑树中这样每次操作系统找就绪的事件就比较快，找到后就链到就绪队列的链表中

这样每次epoll_wait 就只处理就绪队列的事件，比起poll 和 select 每次全部遍历一遍高效的多

LT每一次没处理完就又放到就绪队列中下次epoll_wait还会返回当前未处理完事件

相反 ET 从就绪队列摘下来要处理的事件后就不放回了所以 ET要每次一次性处理完、同时ET模式下文件描述符必须设置为非阻塞的

epoll 默认是LT模式

LT模式水平触发缓冲区没处理完 epoll轮询着下次事件还可以处理上次事件缓冲区剩余的数据

ET模式边缘触发缓冲区的数据每次必须一次性取完否则下次事件触发时上一次事件中没有读取完的数据将丢失

处于 epoll的服务器 ET模式必须一次全部将数据取走所以文件描述符必须设置为非阻塞的因为：如果是阻塞的，while循环read时，最后一次读到文件结尾 read阻塞服务器不能epoll处理别的请求事件

_ev.events = EPOLLIN| EPOLLET 设置事件为 ET模式

代码：设置文件描述符为非阻塞的#include

#include

// 设置文件描述符号不阻塞

int set_noblock(int fd)

{

int fl = fcntl(fd, F_GETFL);// 获取原来文件描述符的状态

if (fl

{

perror("fcntl F_GETFL ");

return 1;

}

if (fcntl(fd, F_SETFL, fl | O_NONBLOCK)

{

perror("fcntl F_SETFL");

return 2;

}

int myfcntl()

{

set_noblock(0);

char buf[10];

while (1)

{

memset(buf, '\0', sizeof(buf));

int ret = read(0, buf, sizeof(buf) - 1);

sleep(1);

printf("%s, ret: %d\n", buf, ret);

}

int main()

{

myfcntl();

return 0;

}

运行：[bozi@localhost fcntl]$ ./fcntl

, ret: -1

练习代码：【epoll ET模式服务器】#include

#include

#define LISTEN_BACK_LOG 10

// 创建监听套接字

int startup(char* ip, int port)

{

int sock = socket(AF_INET, SOCK_STREAM, 0);

if (sock

{

perror("socket");

exit(1);

}

int op = 1;

setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &op, sizeof(int));

struct sockaddr_in local;

local.sin_family = AF_INET;

local.sin_port = htons(port);

local.sin_addr.s_addr= inet_addr(ip);

if (bind(sock, (struct sockaddr*)&local, sizeof(local))

{

perror("bind");

exit(2);

}

if (listen(sock,LISTEN_BACK_LOG)

{

perror("listen");

exit(3);

}

return sock;

}

// 设置文件描述符为非阻塞

static void set_noblock(int fd)

{

int fl = fcntl(fd, F_GETFL);

if (fl

{

perror("fcntl F_GETFL");

return;

}

if (fcntl(fd, F_SETFL, fl|O_NONBLOCK)

{

perror("fcntl F_SETFL");

return;

}

// 处理非阻塞方式的读

static int read_noblock(int fd, char* buf,const int size)

{

int count = 0;

int ret;

while ((ret = read(fd, buf, size - count)) > 0 )//&& errno != EAGAIN)

{

count += ret;

buf = buf + ret;

}

buf[count] = '\0';

return count;

}

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

{

if (argc != 3)

{

printf("please enter: %s [ip] [port]\n", argv[0]);

exit(4);

}

int listen_sock = startup(argv[1], atoi(argv[2]));

// 创建 epoll 句柄事件表

int epfd = epoll_create(101);// 这里数字不固定，100 只是告诉内核预计用100个文件描述符但实际这个参数不起作用只是建议

if (epfd

{

perror("epoll_create");

exit(5);

}

struct epoll_event event;

event.events = EPOLLIN|EPOLLET; // 读事件列表

set_noblock(listen_sock);

event.data.fd = listen_sock;

// 向事件表中增加事件

epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &event);

struct epoll_event fd_events[50];

int size = sizeof(fd_events)/sizeof(fd_events[0]);

int i = 0;

for (i = 0; i

{

fd_events[i].events = 0;

fd_events[i].data.fd = -1;

}

int nums = 0;

int timeout = 10000;

int done = 0;

while (!done)

{

// 返回就绪的文件个数

nums = epoll_wait(epfd, fd_events, size, timeout);

switch (nums)

{

case 0:

printf("timeout...\n");

break;

case -1:

perror("epoll_wait\n");

exit(6) ;

default:

{

for (i = 0; i

{

int fd = fd_events[i].data.fd;

if ((fd == listen_sock) && (fd_events[i].events & EPOLLIN))

{

// listen socket 有新的连接请求

struct sockaddr_in peer;

socklen_t len = sizeof(peer);

int new_sock;

while ((new_sock = accept(listen_sock, (struct sockaddr*)&peer, &len)) > 0)

{

event.events = EPOLLIN|EPOLLET; // ET模式///

set_noblock(new_sock);

event.data.fd = new_sock;

// 将new_sock 添加进内核事件表

epoll_ctl(epfd, EPOLL_CTL_ADD,new_sock, &event);

printf("get a new client, socket->%s:%d\n", inet_ntoa(peer.sin_addr),ntohs(peer.sin_port));

}

continue;

}

else

{

// other socket

// // 读事件满足处理客户端发送的数据

if (fd_events[i].events & EPOLLIN)

{

char buf[1024];

memset(buf, '\0', sizeof(buf));

// ssize_t _s = recv(fd, buf, sizeof(buf) - 1, 0);

int _s = read_noblock(fd, buf, sizeof(buf) - 1);

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

if (_s > 0)

{

printf("client: %s\n", buf);

event.events = EPOLLOUT|EPOLLET;//将fd事件改为写方便服务器给请求的客户端发数据

epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &event);

}

else if (_s == 0)

{

printf("client close...\n");

epoll_ctl(epfd, EPOLL_CTL_DEL,fd,NULL );// 空表示不关心返回值

// event.events = EPOLLOUT|EPOLLET;//将fd事件改为写方便服务器给请求的客户端发数据

// epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &event);

close(fd);

break;

}

else

{

perror("recv");

continue;

}

else if(fd_events[i].events & EPOLLOUT)

{

// WRITE

char *msg = "HTTP/1.1 200 OK\r\n\r\n

hello ^_^

\r\n";

send(fd, msg, strlen(msg), 0);

//event.events = EPOLLIN;

//epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &event);

epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);

close(fd);

}

else

{

}

break;

}

exit(0);

}

运行：

SquaringK

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
linux 多线程 select,Linux多线程编程----IO【select、poll、epoll】

IO操作多速度就下降IO数据的读和写IO的完成必须等到读事件(如磁盘拷贝每次要从磁盘查找数据) 和写事件 (允许写如写太快写满就要马上阻塞)的就绪IO是否高效：主要看一次IO中等的时间的比例的多少 (等的时间比例越少越高效)就像钓鱼分两步：1 等 2 钓 (评价钓鱼技术高效是等的时间少钓的次数多)5中IO模型1 阻塞式IO：等的时候自己等，数据搬...
复制链接

扫一扫