IO复用之poll
主要用一个例程来讲解poll,包含客户端和服务器端。
poll函数没有FD_SETSIZE的限制
int poll(struct pollfd * fdarray, unsigned long nfds, int timeout)
第一个参数：IO数组
第二个：检测的IO个数
struct pollfd
{
int fd;//文件描述符
short events;//请求的事件（感兴趣的事件）
short revents;//返回的事件
};
客户端程序：
1 /*
2 #include <poll.h>
3 int poll(struct pollfd * fdarray,unsigned long nfds,int timeout)
4 第一个参数：IO数组
5 第二个：检测的IO个数
6 struct pollfd
7 {
8 int fd;//文件描述符
9 short events;//请求的事件
10 short revents;//返回的事件
11 };
12
13 */
14 #include<unistd.h>
15 #include<sys/types.h>
16 #include<sys/socket.h>
17 #include<string.h>
18 #include<stdlib.h>
19 #include<stdio.h>
20 #include<errno.h>
21 #include<netinet/in.h>
22 #include<arpa/inet.h>
23 #include<signal.h>
24 #include <sys/time.h>
25
26 #define ERR_EXIT(m)\
27 do\
28 {\
29 perror(m);\
30 exit(EXIT_FAILURE);\
31 }while(0)
32 ssize_t readn(int fd,void *buf,size_t count)
33 {
34 size_t nleft=count;
35 ssize_t nread;
36 char *bufp=(char*)buf;
37 while(nleft>0)
38 {
39 if((nread=read(fd,bufp,nleft))<0)
40 {
41 if(errno==EINTR)
42 continue;
43 else
44 return -1;
45 }
46 else if(nread==0)
47 return (count-nleft);
48 bufp+=nread;
49 nleft-=nread;
50 }
51 return count;
52 }
53 ssize_t writen(int fd, const void *buf, size_t count)
54 {
55 size_t nleft=count;
56 ssize_t nwritten;
57 char *bufp=(char*)buf;
58 while(nleft>0)
59 {
60 if((nwritten=write(fd,bufp,nleft))<=0)
61 {
62 if(errno==EINTR)
63 continue;
64 return -1;
65 }else if(nwritten==0)
66 continue;
67 bufp+=nwritten;
68 nleft-=nwritten;
69 }
70 return count;
71
72 }
73 ssize_t recv_peek(int sockfd,void *buf,size_t len)
74 {
75 while(1)
76 {
77 int ret=recv(sockfd,buf,len,MSG_PEEK);//从sockfd读取内容到buf,但不去清空sockfd,偷窥
78 if(ret==-1&&errno==EINTR)
79 continue;
80 return ret;
81 }
82 }
83 //偷窥方案实现readline避免一次读取一个字符
84 ssize_t readline(int sockfd,void * buf,size_t maxline)
85 {
86 int ret;
87 int nread;
88 size_t nleft=maxline;
89 char *bufp=(char*)buf;
90 while(1)
91 {
92 ret=recv_peek(sockfd,bufp,nleft);//不清除sockfd,只是窥看
93 if(ret<0)
94 return ret;
95 else if(ret==0)
96 return ret;
97 nread=ret;
98 int i;
99 for(i=0;i<nread;i++)
100 {
101 if(bufp[i]=='\n')
102 {
103 ret=readn(sockfd,bufp,i+1);//读出sockfd中的一行并且清空
104 if(ret!=i+1)
105 exit(EXIT_FAILURE);
106 return ret;
107 }
108 }
109 if(nread>nleft)
110 exit(EXIT_FAILURE);
111 nleft-=nread;
112 ret=readn(sockfd,bufp,nread);
113 if(ret!=nread)
114 exit(EXIT_FAILURE);
115 bufp+=nread;//移动指针继续窥看
116 }
117 return -1;
118 }
119 void echo_cli(int sock)
120 {
121 /*
122 char sendbuf[1024]={0};
123 char recvbuf[1024]={0};
124 while(fgets(sendbuf,sizeof(sendbuf),stdin)!=NULL)//默认有换行符
125 {
126
127 writen(sock,sendbuf,strlen(sendbuf));
128 int ret=readline(sock,recvbuf,1024);
129 if(ret==-1)
130 ERR_EXIT("readline");
131 else if(ret==0)
132 {
133 printf("service closed\n");
134 break;
135 }
136 fputs(recvbuf,stdout);
137 memset(sendbuf,0,sizeof(sendbuf));
138 memset(recvbuf,0,sizeof(recvbuf));
139 }
140 */
141 char sendbuf[1024]={0};
142 char recvbuf[1024]={0};
143 fd_set rset;
144 FD_ZERO(&rset);//初始化
145 int nready;//准备好的个数
146 int maxfd;
147 int fd=fileno(stdin);//防止STDIN_FILLENO被重定向
148 if(fd>sock)
149 maxfd=fd;
150 else
151 maxfd=sock;
152 while(1)
153 {
154 FD_SET(fd,&rset);//循环中
155 FD_SET(sock,&rset);
156 nready=select(maxfd+1,&rset,NULL,NULL,NULL);
157 if(nready==-1)
158 ERR_EXIT("select error");
159 if(nready==0)
160 continue;
161 if(FD_ISSET(sock,&rset))
162 {
163 int ret=readline(sock,recvbuf,sizeof(recvbuf));
164 if(ret==-1)
165 ERR_EXIT("readline error");
166 else if(ret==0)
167 {
168 ERR_EXIT("serve closed");
169 break;
170 }
171 fputs(recvbuf,stdout);
172 memset(recvbuf,0,sizeof(recvbuf));
173 }
174 if(FD_ISSET(fd,&rset))
175 {
176 if(fgets(sendbuf,sizeof(sendbuf),stdin)==NULL)
177 break;
178 writen(sock,sendbuf,strlen(sendbuf));
179 memset(sendbuf,0,sizeof(sendbuf));
180 }
181 }
182 close(sock);
183
184 }
185 void handle_sigpipe(int sig)
186 {
187 printf("recive a signal=%d\n",sig);
188
189 }
190 int main(void)
191 {
192 signal(SIGPIPE,handle_sigpipe);//捕捉第二次write的SIGPIPE信号,默认终止进程
193 int sock;
194 if((sock=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
195 ERR_EXIT("socket error");
196
197 struct sockaddr_in servaddr;//本地协议地址赋给一个套接字
198 memset(&servaddr,0,sizeof(servaddr));
199 servaddr.sin_family=AF_INET;
200 servaddr.sin_port=htons(5188);
201
202 servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");//服务器段地址
203 //inet_aton("127.0.0.1",&servaddr.sin_addr);
204
205 if(connect(sock,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
206 ERR_EXIT("connect");
207
208 //利用getsockname获取客户端本身地址和端口,即为对方accept中的对方套接口
209 struct sockaddr_in localaddr;
210 socklen_t addrlen=sizeof(localaddr);
211 if(getsockname(sock,(struct sockaddr *)&localaddr,&addrlen)<0)
212 ERR_EXIT("getsockname error");
213 printf("local IP=%s, local port=%d\n",inet_ntoa(localaddr.sin_addr),ntohs(localaddr.sin_port));
214 //使用getpeername获取对方地址
215 echo_cli(sock);//选择一个与服务器通信
216 return 0;
217 }
服务器端程序：
1 /*
2 #include <poll.h>
3 int poll(struct pollfd * fdarray,unsigned long nfds,int timeout)
4 第一个参数：IO数组
5 第二个：检测的IO个数
6 struct pollfd
7 {
8 int fd;//文件描述符
9 short events;//请求的事件
10 short revents;//返回的事件
11 };
12
13 */
14 #include<unistd.h>
15 #include<sys/types.h>
16 #include<sys/socket.h>
17 #include<string.h>
18 #include<stdlib.h>
19 #include<stdio.h>
20 #include<errno.h>
21 #include<netinet/in.h>
22 #include<arpa/inet.h>
23 #include<signal.h>
24 #include<sys/wait.h>
25 #include<poll.h>
26 #define ERR_EXIT(m)\
27 do\
28 {\
29 perror(m);\
30 exit(EXIT_FAILURE);\
31 }while(0)
32 ssize_t readn(int fd,void *buf,size_t count)
33 {
34 size_t nleft=count;
35 ssize_t nread;
36 char *bufp=(char*)buf;
37 while(nleft>0)
38 {
39 if((nread=read(fd,bufp,nleft))<0)
40 {
41 if(errno==EINTR)
42 continue;
43 else
44 return -1;
45 }
46 else if(nread==0)
47 return (count-nleft);
48 bufp+=nread;
49 nleft-=nread;
50 }
51 return count;
52 }
53 ssize_t writen(int fd, const void *buf, size_t count)
54 {
55 size_t nleft=count;
56 ssize_t nwritten;
57 char *bufp=(char*)buf;
58 while(nleft>0)
59 {
60 if((nwritten=write(fd,bufp,nleft))<=0)
61 {
62 if(errno==EINTR)
63 continue;
64 return -1;
65 }else if(nwritten==0)
66 continue;
67 bufp+=nwritten;
68 nleft-=nwritten;
69 }
70 return count;
71
72 }
73 ssize_t recv_peek(int sockfd,void *buf,size_t len)
74 {
75 while(1)
76 {
77 int ret=recv(sockfd,buf,len,MSG_PEEK);//从sockfd读取内容到buf,但不去清空sockfd,偷窥
78 if(ret==-1&&errno==EINTR)
79 continue;
80 return ret;
81 }
82 }
83 //偷窥方案实现readline避免一次读取一个字符
84 ssize_t readline(int sockfd,void * buf,size_t maxline)
85 {
86 int ret;
87 int nread;
88 size_t nleft=maxline;
89 char *bufp=(char*)buf;
90 while(1)
91 {
92 ret=recv_peek(sockfd,bufp,nleft);//不清除sockfd,只是窥看
93 if(ret<0)
94 return ret;
95 else if(ret==0)
96 return ret;
97 nread=ret;
98 int i;
99 for(i=0;i<nread;i++)
100 {
101 if(bufp[i]=='\n')
102 {
103 ret=readn(sockfd,bufp,i+1);//读出sockfd中的一行并且清空
104 if(ret!=i+1)
105 exit(EXIT_FAILURE);
106 return ret;
107 }
108 }
109 if(nread>nleft)
110 exit(EXIT_FAILURE);
111 nleft-=nread;
112 ret=readn(sockfd,bufp,nread);
113 if(ret!=nread)
114 exit(EXIT_FAILURE);
115 bufp+=nread;//移动指针继续窥看
116 }
117 return -1;
118 }
119 /*
120 signal(SIGCHLD, SIG_IGN)和signal(SIGPIPE, SIG_IGN);
121
122 signal(SIGCHLD, SIG_IGN);
123
124 因为并发服务器常常fork很多子进程，子进程终结之后需要服务器进程去wait清理资源。如果将此信号的处理方式设为忽略，可让内核把僵尸子进程转交给init进程去处理，省去了大量僵尸进程占用系统资源。(Linux Only)
125
126 对于某些进程，特别是服务器进程往往在请求到来时生成子进程处理请求。如果父进程不等待子进程结束，子进程将成为僵尸进程（zombie）从而占用系统资源。如果父进程等待子进程结束，将增加父进程的负担，影响服务器进程的并发性能。在Linux下可以简单地将 SIGCHLD信号的操作设为SIG_IGN。
127
128 signal(SIGPIPE, SIG_IGN);
129
130 TCP是全双工的信道, 可以看作两条单工信道, TCP连接两端的两个端点各负责一条. 当对端调用close时, 虽然本意是关闭整个两条信道,
131 但本端只是收到FIN包. 按照TCP协议的语义, 表示对端只是关闭了其所负责的那一条单工信道, 仍然可以继续接收数据. 也就是说, 因为TCP协议的限制,
132 一个端点无法获知对端的socket是调用了close还是shutdown.
133
134 对一个已经收到FIN包的socket调用read方法,
135 如果接收缓冲已空, 则返回0, 这就是常说的表示连接关闭. 但第一次对其调用write方法时, 如果发送缓冲没问题, 会返回正确写入(发送).
136 但发送的报文会导致对端发送RST报文, 因为对端的socket已经调用了close, 完全关闭, 既不发送, 也不接收数据. 所以,
137 第二次调用write方法(假设在收到RST之后), 会生成SIGPIPE信号, 导致进程退出.
138
139 为了避免进程退出, 可以捕获SIGPIPE信号, 或者忽略它, 给它设置SIG_IGN信号处理函数:
140
141 signal(SIGPIPE, SIG_IGN);
142
143 这样, 第二次调用write方法时, 会返回-1, 同时errno置为SIGPIPE. 程序便能知道对端已经关闭.
144
145 */
146 void handle_sigchld(int sig)
147 {
148
149 while(waitpid(-1,NULL, WNOHANG)>0)
150 ;
151
152 }
153 void handle_sigpipe(int sig)
154 {
155 printf("recevie a sig=%d\n",sig);//打印，不退出服务器进程
156 }
157 int main(void)
158 {
159 int count=0;//测试描述符限制
160 signal(SIGCHLD,handle_sigchld);//避免僵死进程
161 signal(SIGPIPE,handle_sigpipe);//忽略pipe信号。如果客户端关闭套接字close，而服务器端又调用一次write，服务器会接受到RST.如果服务器再调用write产生SIGPIPE
162 int listenfd;
163 if((listenfd=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
164 ERR_EXIT("socket error");
165 //本地协议地址赋给一个套接字
166 struct sockaddr_in servaddr;
167 memset(&servaddr,0,sizeof(servaddr));
168 servaddr.sin_family=AF_INET;
169 servaddr.sin_port=htons(5188);
170 servaddr.sin_addr.s_addr=htonl(INADDR_ANY);//表示本机地址
171
172 //开启地址重复使用,关闭服务器再打开不用等待TIME_WAIT
173 int on=1;
174 if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on))<0)
175 ERR_EXIT("setsockopt error");
176 //绑定本地套接字
177 if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
178 ERR_EXIT("bind error");
179 if(listen(listenfd,SOMAXCONN)<0)//设置监听套接字(被动套接字)
180 ERR_EXIT("listen error");
181
182 struct sockaddr_in peeraddr;//对方套接字地址
183 socklen_t peerlen=sizeof(peeraddr);
184
185 //poll没有fd_set的限制。若进程中最多打开2048个文件描述符
186 struct pollfd client[2048];
187 int i=0;
188 for(i=0;i<2048;i++)
189 {
190 client[i].fd=-1;//保存已连接套接字fd.
191 }
192 int conn;//已连接套接字(主动套接字)
193 int nready;//准备好的事件数，返回值
194 int maxi=0;//当前client数组中正在使用的最大下标值，关心的事件个数
195 client[0].fd=listenfd;
196 client[0].events=POLLIN;//只对监听套接口的可读事件感兴趣
197 while(1)
198 {
199 nready=poll(client,maxi+1,-1);//[0,maxi]
200 if(nready==-1)
201 {
202 if(errno==EINTR)
203 continue;
204 ERR_EXIT("select error");
205 }
206 if(nready==0)
207 continue;
208 //判断是不是监听套接口产生了事件
209 //返回的事件与上 POLLIN,如果等于1 表明监听套接字产生了可读事件
210 if(client[0].revents & POLLIN)
211 {
212 conn=accept(listenfd,(struct sockaddr *)&peeraddr,&peerlen);
213 if(conn==-1)
214 ERR_EXIT("accept");
215 for(i=0;i<2018;i++)
216 {
217 if(client[i].fd<0)
218 {
219 client[i].fd=conn;
220 client[i].events=POLLIN;
221 if(i>maxi)
222 maxi=i;
223 break;
224 }
225 }
226 if(i==2048)
227 {
228 fprintf(stderr,"too many clients\n");
229 exit(EXIT_FAILURE);
230 }
231 printf("ip=%s port=%d\n",inet_ntoa(peeraddr.sin_addr),ntohs(peeraddr.sin_port));
232 printf("count=%d\n",++count);
233
234 if(--nready<=0)
235 continue;
236 }
237 //判断是不是已连接套接口产生了事件
238 for(i=1;i<=maxi;i++)
239 {
240 conn=client[i].fd;
241 if(conn==-1) continue;
242 if(client[i].revents & POLLIN)
243 {
244 char recvbuf[1024]={0};
245 int ret=readline(conn,recvbuf,1024);
246 if(ret==-1)
247 ERR_EXIT("readline");
248 if(ret==0)
249 {
250 printf("client close\n");
251 client[i].fd=-1;
252 close(conn);
253 }
254 fputs(recvbuf,stdout);
255 writen(conn,recvbuf,strlen(recvbuf));
256 if(--nready<=0)
257 break;
258 }
259 }
260 }
261 return 0;
262 }
Makefile文件
.PHONY:clean all
CC=gcc
CFLAGS=-Wall -g
BIN＝ poll_cli poll_ser
all:$(BIN)
%.o:%.c
$(CC) $(CFLAGS) -c $^ -o $@
clean:
rm -f *.o $(BIN)
IO复用之poll的更多相关文章
- IO复用： select 和poll 到epoll
linux 提供了select.poll和epoll三种接口来实现多路IO复用.下面总结下这三种接口. select 该函数允许进程指示内核等待多个事件中的任何一个发生,并只在有一个或多个事件发生或经 ...
- 第十六篇：初探IO复用
前言 在之前的文章中,我具体实现了一个并发回射服务器并给它加载了僵尸子进程的自动清理信号机制.在正常情况下,它已经可以很好地工作了,但它能否合理应对一些特殊情况呢? 问题发现 先来看看当服务器的客户子 ...
- 初探IO复用
前言 在之前的文章中,我具体实现了一个并发回射服务器并给它加载了僵尸子进程的自动清理信号机制.在正常情况下,它已经可以很好地工作了,但它能否合理应对一些特殊情况呢? 问题发现 先来看看当服务器的客户子 ...
- select、poll、epoll三组IO复用
int select(int nfds,fd_set* readfds,fd_set* writefds,fd_set* exceptfds,struct timeval* timeout)//其中n ...
- 【Unix网络编程】chapter6 IO复用：select和poll函数
chapter6 6.1 概述 I/O复用典型使用在下列网络应用场合. (1):当客户处理多个描述符时,必须使用IO复用 (2):一个客户同时处理多个套接字是可能的,不过不叫少见. (3):如果一个T ...
- 多路IO复用模型--select, poll, epoll
select 1.select能监听的文件描述符个数受限于FD_SETSIZE,一般为1024,单纯改变进程打开的文件描述符个数并不能改变select监听文件个数 2.解决1024以下客户端时使用se ...
- Select、Poll、Epoll IO复用技术
简介 目前多进程方式实现的服务器端,一次创建多个工作子进程来给客户端提供服务, 但是创建进程会耗费大量资源,导致系统资源不足 IO复用技术就是让一个进程同时为多个客户端端提供服务 IO复用技术 之 S ...
- IO复用的三种方法（select,poll,epoll）深入理解
(一)IO复用是Linux中的IO模型之一,IO复用就是进程告诉内核需要监视的IO条件,使得内核一旦发现进程指定的一个或多个IO条件就绪,就通过进程处理,从而不会在单个IO上阻塞了,Linux中,提供 ...
- Linux网络编程-IO复用技术
IO复用是Linux中的IO模型之一,IO复用就是进程预先告诉内核需要监视的IO条件,使得内核一旦发现进程指定的一个或多个IO条件就绪,就通过进程进程处理,从而不会在单个IO上阻塞了.Linux中,提 ...
随机推荐
- IDEA 简拼输入
1. sout = System.out.println(); 2. soutp = System.out.println(""); 3. soutv = System.out.p ...
- 【转载】动态规划—各种 DP 优化
原博客地址 关于氵博客:其实主要是防止我找不到这篇文了
- 这玩意比ThreadLocal叼多了，吓得why哥赶紧分享出来。
这是why哥的第 70 篇原创文章 从Dubbo的一次提交开始 故事得从前段时间翻阅 Dubbo 源码时,看到的一段代码讲起. 这段代码就是这个: org.apache.dubbo.rpc.RpcCo ...
- Typora图片一键传——picgo使用兰空图床
Typora picgo使用兰空图床 最近smms图床免费版的速度眼看着越来越慢,特别是到晚上,图片几乎是在原地打转,于是我想替换掉Typora中picgo默认使用的smms图床,网上的教程清一色地只 ...
- javaSE、javaEE、Android知识点总结
曾今上学时候的一些学习总结,如有错误请大家指出,共同学习. 1. 什么是WebView? WebView是一个使用WebKit引擎的浏览器组件,用来加载网页. 2. WebView中加载网页的两种方式 ...
- 自学Python可以吗？怎样从入门到大师？我写这篇文章告诉你
前言 很多粉丝朋友问我该如何去学习爬虫.学习Python.自学能找到工作吗?等一系列的问题.今天我就来回答一下大家. 第一点 确定好方向与目标 当决定踏入这个行业那一刻起,我想每一个人都爱已经准备投身 ...
- LIS初级推算（最长上升子序列问题）
所谓LIS,就是Longest Increasing Subsequence问题 注意,子序列不一定是连续的,举个例子:对于序列10,9,2,3,5,4,7,9,101,18,其中的LIS就是2,3, ...
- drf Serializer使用
drf序列化 在前后端不分离的项目中,可以使用Django自带的forms组件进行数据验证,也可以使用Django自带的序列化组件对模型表数据进行序列化. 那么在前后端分离的项目中,drf也提供了数据 ...
- 为什么网上有很多人说Python不要学
随着"大数据""云计算""人工智能"等等科技的兴起,IT行业在今后三到五年将会迎来一个高速发展期.这也就意味着会出现大量的人才缺口,尤其 ...
- http与https随笔
http: 超文本传输协议.使用TCP/IP协议 https: 安全超文本传输协议.使用TLS/SSL协议 不同: 1.安全 http是明文传输.http是具有安全性的SSL加密传输协议. https ...