lv6 网络编程(6)IO多路复用

目录

前言

1.IO模型

1.1阻塞IO

1.2非阻塞I/O

1.3I/O 多路复用

1.3.1 select()/poll()实现多路复用

代码演示:服务器端使用select

1.4信号驱动I/O

2.epoll的使用

总结


 



前言

1.IO模型

在UNIX/Linux下主要有4种I/O 模型:

阻塞I/O:最常用
非阻塞I/O:可防止进程阻塞在I/O操作上,需要轮询
I/O 多路复用:允许同时对多个I/O进行控制
信号驱动I/O:  一种异步通信模型

1.1阻塞IO

阻塞I/O 模式是最普遍使用的I/O 模式,大部分程序使用的都是阻塞模式的I/O 。
缺省情况下,套接字建立后所处于的模式就是阻塞I/O 模式。

前面学习的很多读写函数在调用过程中会发生阻塞。
读操作中的read、recv、recvfrom
写操作中的write、send
其他操作:accept、connect

注意:sendto函数不是阻塞函数,这是因为UDP协议的特殊性

1.1.1读阻塞

以read函数为例:
进程调用read函数从套接字上读取数据,当套接字的接收缓冲区中还没有数据可读,函数read将发生阻塞。
它会一直阻塞下去,等待套接字的接收缓冲区中有数据可读。
经过一段时间后,缓冲区内接收到数据,于是内核便去唤醒该进程,通过read访问这些数据。
如果在进程阻塞过程中,对方发生故障,那这个进程将永远阻塞下去。

1.1.2写阻塞

在写操作时发生阻塞的情况要比读操作少。主要发生在要写入的缓冲区的大小小于要写入的数据量的情况下。
这时,写操作不进行任何拷贝工作,将发生阻塞。
一量发送缓冲区内有足够的空间,内核将唤醒进程,将数据从用户缓冲区中拷贝到相应的发送数据缓冲区。
UDP不用等待确认,没有实际的发送缓冲区,所以UDP协议中不存在发送缓冲区满的情况,在UDP套接字上执行的写操作永远都不会阻塞。

1.2非阻塞I/O

当我们将一个套接字设置为非阻塞模式,我们相当于告诉了系统内核:“当我请求的I/O 操作不能够马上完成,你想让我的进程进行休眠等待的时候,不要这么做,请马上返回一个错误给我。”
当一个应用程序使用了非阻塞模式的套接字,它需要使用一个循环来不停地测试是否一个文件描述符有数据可读(称做polling)。
应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作
这种模式使用中不普遍。

lv6 网络编程(6)IO多路复用_第1张图片

 fcntl()函数 -- 非阻塞实现
当你一开始建立一个套接字描述符的时候,系统内核将其设置为阻塞IO模式。
可以使用函数fcntl()设置一个套接字的标志为O_NONBLOCK 来实现非阻塞。
代码实现;
1.fcntl( )函数

int fcntl(int fd, int cmd, long arg);
      int flag;
      flag = fcntl(sockfd, F_GETFL, 0);
      flag |= O_NONBLOCK;
      fcntl(sockfd, F_SETFL, flag);
2.ioctl() 函数    
   int b_on =1;
   ioctl(sock_fd, FIONBIO, &b_on);

1.3I/O 多路复用

应用程序中同时处理多路输入输出流,若采用阻塞模式,将得不到预期的目的;
若采用非阻塞模式,对多个输入进行轮询,但又太浪费CPU时间;

若设置多个进程,分别处理一条数据通路,将新产生进程间的同步与通信问题,使程序变得更加复杂;

linux每个进程在默认情况下,最多打开1024个文件,最多有1024个文件描述符。

多路复用针对的不止套接字fd,也包括普通文件描述fd。

文件描述符特点:

1.非负整数

2.从最小可以数字来分配

3.每个进程启动时默认打开0,1,2三个文件描述符

比较好的方法是使用I/O多路复用。其基本思想是:
先构造一张有关描述符的表,然后调用一个函数。当这些文件描述符中的一个或多个已准备好进行I/O时函数才返回。
函数返回时告诉进程那个描述符已就绪,可以进行I/O操作。

1.3.1 select()/poll()实现多路复用

#include
#include
#include

int select(int n, fd_set *read_fds, fd_set *write_fds, fd_set *except_fds, struct timeval *timeout);

maxfd
所有监控的文件描述符中最大的那一个加1
read_fds
所有要读的文件文件描述符的集合
write_fds
所有要的写文件文件描述符的集合
except_fds
其他要向我们通知的文件描述符
timeout
超时设置.
Null:一直阻塞,直到有文件描述符就绪或出错
时间值为0:仅仅检测文件描述符集的状态,然后立即返回
时间值不为0:在指定时间内,如果没有事件发生,则超时返回。

select执行流程:

1.把关心文件描述符放入到集合中(fd_set)

2.调用select()/poll()函数去监控集合fd_set中哪些文件描述符(阻塞等待集合中一个或多个文件描述有数据)

3.当有数据时,退出select()阻塞

4.依次判断哪个文件描述有数据

5.依次处理有数据的文件描述符的数据

在我们调用select时进程会一直阻塞直到以下的一种情况发生.
有文件可以读.
有文件可以写.
超时所设置的时间到.

为了设置文件描述符我们要使用几个宏:
FD_SET       将fd加入到fdset
FD_CLR      将fd从fdset里面清除
FD_ZERO   从fdset中清除所有的文件描述符
FD_ISSET   判断fd是否在fdset集合中

宏的形式:
void FD_ZERO(fd_set *fdset)
void FD_SET(int fd,fd_set *fdset)
void FD_CLR(int fd,fd_set *fdset)
int FD_ISSET(int fd,fd_set *fdset)

lv6 网络编程(6)IO多路复用_第2张图片

关键点:
  1. select( )函数里面的各个文件描述符fd_set集合的参数在select( )前后发生了变化:
 前:表示关心的文件描述符集合
 后:有数据的集合(如不是在超时还回情况下)

   2. 那么究竟是谁动了fd_set集合的奶酪?
    答曰:kernel
  思考:       这种模式下,多路网络连接时候能否真正多路并发处理?如果能,请说明理由,如不能,请给出改进意见     

#include
int poll(struct pollfd *ufds, unsigned int nfds, int timeout);

代码演示:服务器端使用select

1.server端

#include "net.h"
#include 

void* childProcesstest(void*);

void handler(int arg){
	if(SIGCHLD == arg){//触发回收子进程
		waitpid(-1,NULL,WNOHANG);
	}
}

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

	int fd;
	struct sockaddr_in sin;
	//signal(SIGCHLD,handler);
	//1.创建socket fd

	fd = socket(AF_INET,SOCK_STREAM,0);
	if(fd < 0){
		perror("socket");
		exit(0);
	}
	/*优化4: 允许绑定地址快速重用 */
	int b_reuse = 10;
	setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));

	//2.bind函数
	bzero(&sin,sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(SERV_PORT);
	//优化1
#if 0
	sin.sin_addr.s_addr = htonl(INADDY_ANY);
#else
	if(inet_pton(AF_INET,SERV_IP_ADDR,&sin.sin_addr)< 0){
		perror("inet_pton");
		exit(0);
	}
#endif
	if(	bind(fd,(struct sockaddr*)&sin,sizeof(sin)) < 0){
		perror("bind");
		exit(0);	
	}	
	//3.listen()函数
	listen(fd,5);

	//4.1 accept
	int newfd = -1;	
	struct sockaddr_in cin;
	socklen_t socklen  = sizeof(cin);


	//5.实现IO多路复用
	int maxfd = -1;
	int ret,readwrite;
	char buf[BUFSIZ];
	char buf02[BUFSIZ + 10];
	fd_set rset;
	fd_set rset_temp;//副表
	struct timeval tout;
	tout.tv_sec = 5;
	tout.tv_usec = 0;
	maxfd = maxfd > fd? maxfd:fd;

	FD_SET(fd,&rset);//加入到集合
	printf("fd=%d\n",fd);//3
	while(1){
		rset_temp = rset;

		ret = select(maxfd+1,&rset_temp,NULL,NULL,&tout);//返回连接的个数
		if(ret < 0){
			perror("select\n");
		}
		//在循环里面判断是连接还是数据
		int i;
		for(i=3;inewfd?maxfd:newfd;//每次有新的文件描述符加入就更新最大文件描述符
					char ipv4_addr[16];
					if(!inet_ntop(AF_INET,&cin.sin_addr,ipv4_addr,socklen)){
						perror("inet_ntop");
						exit(0);
					}
					printf("client(%s,%d) is connect\n",ipv4_addr,ntohs(cin.sin_port));
				}else{//说明有新的数据读取

					bzero(buf,sizeof(buf));
					bzero(buf02,sizeof(buf02));
					do{	
						readwrite = read(i,buf,BUFSIZ-1);
					}while(readwrite < 0 && EINTR == errno);


					if(readwrite < 0){
						perror("read");
						exit(0);
					}
					if(!readwrite){
						FD_CLR(i,&rset);//客户端断开连接,从集合里面清除i
						close(i);
						continue;
					}
					printf("result=%s\n",buf);

					//返回消息给发送端
					strncpy(buf02,BUFADD,strlen(BUFADD));
					strcat(buf02,buf);
					do{
						readwrite = write(newfd,buf02,strlen(buf02));
					}while(readwrite < 0 && EINTR == errno);


					if(!strncasecmp(buf,QUIT,strlen(QUIT))){
						FD_CLR(i,&rset);//客户端断开连接,从集合里面清除i
						close(i);
						printf("通话结束fd = %d\n",i);
					}
					/*over...*/
				}
				//ret--;
			}	
		}
	}
	close(fd);
	return 0;
}

2.client端


/*./client serv_ip serv_port */
#include "net.h"

void usage (char *s)
{
	printf ("\n%s serv_ip serv_port", s);
	printf ("\n\t serv_ip: server ip address");
	printf ("\n\t serv_port: server port(>5000)\n\n");
}

int main (int argc, char **argv)
{
	int fd = -1;

	int port = -1;
	struct sockaddr_in sin;

	if (argc != 3) {
		usage (argv[0]);
		exit (1);
	}
	/* 1. 创建socket fd */
	if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
		perror ("socket");
		exit (1);
	}

	port = atoi (argv[2]);
	if (port < 5000) {
		usage (argv[0]);
		exit (1);
	}
	/*2.连接服务器 */

	/*2.1 填充struct sockaddr_in结构体变量 */
	bzero (&sin, sizeof (sin));

	sin.sin_family = AF_INET;
	sin.sin_port = htons (port);	//网络字节序的端口号
#if 0
	sin.sin_addr.s_addr = inet_addr (SERV_IP_ADDR);
#else
	if (inet_pton (AF_INET, argv[1], (void *) &sin.sin_addr) != 1) {
		perror ("inet_pton");
		exit (1);
	}
#endif

	if (connect (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
		perror ("connect");
		exit (1);
	}

	printf ("Client staring...OK!\n");

	int ret = -1;
	fd_set rset;
	int maxfd = -1;
	struct timeval tout;
	char buf[BUFSIZ];

	while (1) {
		FD_ZERO (&rset);
		FD_SET (0, &rset);
		FD_SET (fd, &rset);
		maxfd = fd;

		tout.tv_sec = 5;
		tout.tv_usec = 0;

		select (maxfd + 1, &rset, NULL, NULL, &tout);
		if (FD_ISSET (0, &rset)) {	//标准键盘上有输入
			//读取键盘输入,发送到网络套接字fd
			bzero (buf, BUFSIZ);
			do {
				ret = read (0, buf, BUFSIZ - 1);
			} while (ret < 0 && EINTR == errno);
			if (ret < 0) {
				perror ("read");
				continue;
			}
			if (!ret)
				continue;

			if (write (fd, buf, strlen (buf)) < 0) {
				perror ("write() to socket");
				continue;
			}

			if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) {	//用户输入了quit字符
				printf ("Client is exiting!\n");
				break;
			}
		}

		if (FD_ISSET (fd, &rset)) {	//服务器给发送过来了数据
			//读取套接字数据,处理
			bzero (buf, BUFSIZ);
			do {
				ret = read (fd, buf, BUFSIZ - 1);
			} while (ret < 0 && EINTR == errno);
			if (ret < 0) {
				perror ("read from socket");
				continue;
			}
			if (!ret)
				break;			/* 服务器关闭 */

			//There is a BUG,FIXME!!
			printf ("server said: %s\n", buf);
			if ((strlen(buf) > strlen(SERV_RESP_STR)) 
				&& !strncasecmp (buf+strlen(SERV_RESP_STR), QUIT_STR, strlen (QUIT_STR))) {	//用户输入了quit字符
				printf ("Sender Client is exiting!\n");
				break;
			}

		}
	}

	/*4.关闭套接字 */
	close (fd);
}

3.net.h端

#ifndef __MAKEU_NET_H__
#define __MAKEU_NET_H__

#include 
#include 
#include 
#include 
#include 
#include 
#include 			/* See NOTES */
#include 
#include 
#include 			/* superset of previous */

#include 
#include 
//#include 
#include 



#define SERV_PORT 5002
#define SERV_IP_ADDR "192.168.7.246"
#define BACKLOG 5

#define QUIT_STR "quit"
#define SERV_RESP_STR "SERVER:"
#endif

1.4信号驱动I/O

2.epoll的使用

深入理解epoll和select/poll的区别,重点。详情参考文末的参考文献。

1.server端 服务端修改为epoll的结构

#include "net.h"
#include 


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

	int fd;
	struct sockaddr_in sin;
	//1.创建socket fd

	fd = socket(AF_INET,SOCK_STREAM,0);
	if(fd < 0){
		perror("socket");
		exit(0);
	}
	/*优化4: 允许绑定地址快速重用 */
	int b_reuse = 10;
	setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));

	//2.bind函数
	bzero(&sin,sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(SERV_PORT);
	//优化1
#if 0
	sin.sin_addr.s_addr = htonl(INADDY_ANY);
#else
	if(inet_pton(AF_INET,SERV_IP_ADDR,&sin.sin_addr)< 0){
		perror("inet_pton");
		exit(0);
	}
#endif
	if(	bind(fd,(struct sockaddr*)&sin,sizeof(sin)) < 0){
		perror("bind");
		exit(0);	
	}	
	//3.listen()函数
	listen(fd,5);

	//4.1 accept需要的参数定义
	int newfd = -1;	
	struct sockaddr_in cin;
	socklen_t socklen  = sizeof(cin);

	int ret,readwrite;
	char buf[BUFSIZ];
	char buf02[BUFSIZ + 10];

	//5.实现IO多路复用
	int maxfd = -1;
	int epfd;

	struct epoll_event event;
	struct epoll_event events[20];
	memset(events,0,20*sizeof(struct epoll_event));

	event.events = EPOLLIN;//对应的文件描述符可读
	event.data.fd = fd;

	epfd = epoll_create(1);//创建epoll

	epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&event);//fd是需要监听的fd


	while(1){

		ret = epoll_wait(epfd,events,20,-1);//等待epfd上的io事件,最多返回20个事件。
		if(ret < 0){
			perror("select\n");
		}
		//在循环里面判断是连接还是数据
		int i;
		for(i=0;i< ret ;i++){
			if(events[i].data.fd == fd){//有任务事件的文件描述符

				//阻塞等待客户端连接
				newfd = accept(events[i].data.fd,(struct sockaddr*)&cin,&socklen);
				if(newfd < 0){
					perror("accept");
					exit(0);
				}

				event.events = EPOLLIN;//对应的文件描述符可读
				event.data.fd = newfd;
				epoll_ctl(epfd,EPOLL_CTL_ADD,newfd,&event);
				//打印客户端信息
				char ipv4_addr[16];
				if(!inet_ntop(AF_INET,&cin.sin_addr,ipv4_addr,socklen)){
					perror("inet_ntop");
					exit(0);
				}
				printf("client(%s,%d) is connect\n",ipv4_addr,ntohs(cin.sin_port));
			}else{//说明有新的数据读取

				bzero(buf,sizeof(buf));
				bzero(buf02,sizeof(buf02));
				do{	
					readwrite = read(events[i].data.fd,buf,BUFSIZ-1);
				}while(readwrite < 0 && EINTR == errno);


				if(readwrite < 0){
					perror("read");
					exit(0);
				}
				if(!readwrite){
					//客户端断开连接,从集合里面清除i

					event.events = EPOLLIN;//对应的文件描述符可读
					event.data.fd = events[i].data.fd;
					epoll_ctl(epfd,EPOLL_CTL_DEL,events[i].data.fd,&event);
					close(events[i].data.fd);
					continue;
				}
				printf("result=%s\n",buf);

				//返回消息给发送端
				strncpy(buf02,BUFADD,strlen(BUFADD));
				strcat(buf02,buf);
				do{
					readwrite = write(newfd,buf02,strlen(buf02));
				}while(readwrite < 0 && EINTR == errno);


				if(!strncasecmp(buf,QUIT,strlen(QUIT))){
					event.events = EPOLLIN;//对应的文件描述符可读
					event.data.fd = events[i].data.fd;
					epoll_ctl(epfd,EPOLL_CTL_DEL,events[i].data.fd,&event);
					close(events[i].data.fd);
					printf("通话结束fd = %d\n",events[i].data.fd);
				}
				/*over...*/
			}
			//ret--;
		}	
	}
	close(fd);
	return 0;
}


总结

多路复用参考文献:

参考直播: http://www.makeru.com.cn/live/5413_1937.html(参考代码见课程资料)
参考博客: https://segmentfault.com/a/1190000003063859
参考播客: http://blog.csdn.net/davidsguo008/article/details/73556811

你可能感兴趣的:(linux,服务器)