Select管理IO（笔记）

最新推荐文章于 2024-09-10 20:57:59 发布
最新推荐文章于 2024-09-10 20:57:59 发布
阅读量473 收藏
点赞数
分类专栏： 网络编程和进程通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34938530/article/details/79799889
版权

    用select来管理多个IO。一旦其中的一个IO或者多个IO检测到我们所感兴趣的事件，select函数返回，返回值为检测到的事件个数，并且返回那些IO发生了事件。

int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);

参数说明：

    1、读、写、异常集合中的文件描述符的最大值+1.

    2、读集合。

    3、写集合

    4、异常

    5.超时结构体

读、写、异常事件发生条件：

    1.可读：

                套接口缓冲区有数据可读。

                连接的读一半关闭，即接收到FIN段，读操作将返回0。

                如果是监听套接口，已完成连接队列不为空时。

                套接口上发生了一个错误待处理，错误可以通过getsockopt指定SO_ERROR选项来获取。

    2.可写：

                套接口发送缓冲区有空间可容纳数据。

                连接的写一半关闭。即收到RST段之后，再次调用write操作。

                套接口上发生了一个错误待处理，错误可以通过getsockopt指定SO_ERROR选项来获取。

    3.异常：

                套接口存在带外数据。

附上测试代码：

服务器端：

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <signal.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#define ERR_EXIT(m)			\
	do				\
	{				\
		perror(m);		\
		exit(EXIT_FAILURE);	\
	}while(0);			\

struct packet
{
	int len;
	char buf[1024];
};

ssize_t readn(int fd,void *buf,size_t count)
{
	size_t	nleft = count;			//剩余要读取的字节数
	ssize_t	nread;				
	char *bufp = (char*)buf;

	while(nleft>0)
	{
		if( (nread = read(fd,bufp,nleft)) < 0)
		{
			if(errno == EINTR)	/*被信号中断*/
				continue;
			return -1;		//读取失败
		} 

		else if(nread == 0)
		{
			return count-nleft;	//剩余的字节数
		}

		else 
		{
			bufp += nread;		//设置下一次读取时的位置
			nleft -= nread;		//剩余要读取的字节数
		}

	}

	return count;				//全部的字节数
}

ssize_t writen(int fd,const void *buf,size_t count)
{
	size_t nleft = count;			//剩余要写入的字节数
	ssize_t nwritten;
	char *bufp = (char*)buf;

	while(nwritten > 0)
	{
		if( (nwritten = write(fd,bufp,nleft)) < 0 )
		{
			if(errno == EINTR)	/*被信号中断*/
				continue;
			return -1;
			
		}

		else if(nwritten == 0)
		{
			return count-nleft;	//剩余的字节数
		}
		else 
		{
			bufp += nwritten;		//设置下一次写入的位置
			nleft -= nwritten;
		}
	}

	return count;
}

void handle_sigpipe(int sig)
{
	printf("recv sig = %d\n",sig);
}

int main(void)
{
	signal(SIGPIPE,handle_sigpipe);
	int listenfd;
	
	if((listenfd =  socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
	{
		ERR_EXIT("socket");	
	}

	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));	//初始化

	servaddr.sin_family = AF_INET;		//地址族	
	servaddr.sin_port = htons(5188);	//端口号
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

	/*设置地址重复利用*/
	int on = 1;
	if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)) < 0)
	{
		ERR_EXIT("setsockopt");
	}

	/*绑定*/
	if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)) < 0 )
	{
		ERR_EXIT("bind");
	}
	
	/*绑定监听*/
	if(listen(listenfd,SOMAXCONN) < 0)
	{
		ERR_EXIT("listen");
	}        


	struct sockaddr_in peeraddr;		/*目标地址*/
	socklen_t peerlen;	

	int conn;
	struct packet  recvbuf;
	memset(&recvbuf,0,sizeof(recvbuf));

	int n;
	int client[FD_SETSIZE];
	int i;
	for (i=0; i<FD_SETSIZE; i++)
	{
		client[i] = -1;
	}
	int nready;
	int maxfd = listenfd;
	fd_set rset;
	fd_set allset;
	FD_ZERO(&rset);
	FD_ZERO(&allset);
	FD_SET(listenfd,&allset);
	while (1)
	{
		rset = allset;
		nready = select(maxfd+1,&rset,NULL,NULL,NULL);
		if (nready == -1)
		{
			if (errno == EINTR)
				continue;
			ERR_EXIT("select");
		}
		if (nready == 0)
			continue;
		/*监听套接口产生的事件*/
		if (FD_ISSET(listenfd,&rset))
		{
			peerlen = sizeof(peeraddr);
			conn = accept(listenfd,(struct sockaddr*)&peeraddr,&peerlen);
			if (conn == -1)
                		ERR_EXIT("accept");
			for (i=0; i<FD_SETSIZE; i++)
			{
				if (client[i] < 0)
				{
					client[i] = conn;
					break;
				}
			}

			if (i == FD_SETSIZE)
			{
				fprintf(stderr,"too many clients\n");
				exit(EXIT_FAILURE);
			}
			printf("ip = %s,port = %d\n",inet_ntoa(peeraddr.sin_addr),peeraddr.sin_port);

			FD_SET(conn,&allset);
			if (conn > maxfd)
				maxfd = conn;
			if (--nready <= 0)
				continue;
		}
		
		/*已连接套接口产生的事件*/
		for (i=0; i<FD_SETSIZE; i++)
		{
			conn = client[i];
			if (conn == -1)
				continue;
			if (FD_ISSET(conn,&rset))
			{
				memset(&recvbuf,0,sizeof(recvbuf));
                		int ret = readn(conn,&recvbuf.len,4);           //先接收4个字节
                		if(ret == -1)
                		{
                        		ERR_EXIT("read");
                		}
                
               		 	if(ret < 4)
                		{
                        		printf("click close\n");
					FD_CLR(conn,&allset);
					client[i] = -1;
                        		break;
                		}
                		n = ntohl(recvbuf.len);
                		ret = readn(conn,&recvbuf.buf,n);
                
                		if(ret == -1)
                		{
                        		ERR_EXIT("read");
                		}
                		if(ret < n)
                		{       
                        		printf("click close\n");
					FD_CLR(conn,&allset);
					client[i] = -1;
                        		close(client[i]);
                		}
                		fputs(recvbuf.buf,stdout);
				writen(conn,&recvbuf,4+n);
				if (--nready <= 0 )
					break;
			}
		}		
	}
	return 0;
                                                                                                                                                                                                   
}

客户端：

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#define ERR_EXIT(m)			\
	do				\
	{				\
		perror(m);		\
		exit(EXIT_FAILURE);	\
	}while(0);			\


struct packet
{
	int len;				//存放实际的数据长度
	char buf[1024];
};

ssize_t readn(int fd,void *buf,size_t count)
{
        size_t  nleft = count;                  //剩余要读取的字节数
        ssize_t nread;
        char *bufp = (char*)buf;

        while(nleft>0)
        {
                if( (nread = read(fd,bufp,nleft)) < 0)
                {
                        if(errno == EINTR)      /*被信号中断*/
                                continue;
                        return -1;              //读取失败
                }

                else if(nread == 0)
                {
                        printf("peer close\n");
                        return count-nleft;     //剩余的字节数
                }

                else
                {
                        bufp += nread;          //设置下一次读取时的位置
                        nleft -= nread;         //剩余要读取的字节数
                }

        }

        return count;                           //全部的字节数
}


ssize_t writen(int fd,const void *buf,size_t count)
{
        size_t nleft = count;                   //剩余要写入的字节数
        ssize_t nwritten;
        char *bufp = (char*)buf;

        while(nwritten > 0)
        {
                if( (nwritten = write(fd,bufp,nleft)) < 0 )
                {
                        if(errno == EINTR)      /*被信号中断*/
                                continue;
                        return -1;

                }

                else if(nwritten == 0)
                {                        
			return count-nleft;     //剩余的字节数
                
}
                else
                {
                        bufp += nwritten;       //设置下一次写入的位置
                        nleft -= nwritten;
                }
        }

        return count;

}


int main(void)
{
	int sock;

	if((sock =  socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
	{
		ERR_EXIT("socket");	
	}

	/*if(listenfd = socket(PF_INET,SOCK_STREAM,0)<0)*/

	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));	//初始化

	servaddr.sin_family = AF_INET;		//地址族	
	servaddr.sin_port = htons(5188);	//端口号
	/*servaddr.sin_addr.s_addr = htonl(INADDR_ANY);*/
	servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	/*iner_aton("127.0.0.1",&servaddr.sin_addr);*/

	if( connect(sock,(struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)
	{
		ERR_EXIT("connect");
	}	
		
	fd_set rset;
	FD_ZERO(&rset);

	int nready;
	int maxfd;
	int fd_stdin = fileno(stdin);

	if (fd_stdin > sock)
		maxfd = fd_stdin;
	else 
		maxfd = sock;
	struct packet sendbuff;
        struct packet recvbuff;

	memset(&sendbuff,0,sizeof(sendbuff));
        memset(&recvbuff,0,sizeof(recvbuff));
        printf("ip = %s,port = %d\n",inet_ntoa(servaddr.sin_addr),servaddr.sin_port);
	while (1)
	{
		FD_SET(fd_stdin,&rset);
		FD_SET(sock,&rset);
		nready = select(maxfd+1,&rset,NULL,NULL,NULL);
		if (nready == -1)
			ERR_EXIT("select");
		if (nready == 0)
			continue;
		
		if (FD_ISSET(sock,&rset))
		{
			int ret = readn(sock,&recvbuff.len,4);           //先接收4个字节
                	if(ret == -1)
                	{
                        	ERR_EXIT("read");
                	}
                	else if(ret < 4)
                	{
                        	printf("click close\n");
                        	break;
                	}

                	int n = ntohl(recvbuff.len);
               		ret = readn(sock,&recvbuff.buf,n);

                	if(ret == -1)
                	{
                        	ERR_EXIT("read");
                	}
                	else if(ret < n)
                	{
                        	printf("server close\n");
                        	break;
                	}
                	fputs(recvbuff.buf,stdout);
                	memset(&recvbuff,0,sizeof(recvbuff));
		}
		if (FD_ISSET(fd_stdin,&rset))
		{
			if(fgets(sendbuff.buf,sizeof(sendbuff.buf),stdin) == NULL)
			{
				
				shutdown(sock,SHUT_WR);
			}
			int n = strlen(sendbuff.buf);
                	sendbuff.len = htonl(n);
                	writen(sock,&sendbuff,4+n);
			memset(&sendbuff,0,sizeof(sendbuff));

		}
	}	

	return 0;
                                                                                                                                                                                                   
}



IT呵呵哒
关注
专栏目录
select IO模式
06-25
典型的Select IO模式结构,非常实用
Xilinx selectIO
weixin_30414245的博客
04-28 582
Virtex系列的FPGA的基本I/O逻辑资源都包括组合输入、输出资源，三态输出控制、寄存器输入输出控制、SDR输入输出、DDR输出三态控制等。此外V5、V6器件还包括了IODELAY提供了对高分辨率可调整延迟单元的用户控制、SAME_EDGE输出DDR模式，SAME_EDGA和SAME_EDGA_PIPELINED输入DDR模式等，以下主要是总结个人学习记录。 一、输入输出延迟单元IODE...
select函数详解：IO复用
最新发布
m0_58572142的博客
09-10 1190
select函数是一种用于实现I/O复用的方法，它可以让程序在多个文件描述符（例如套接字）之间进行选择，以便在其中任何一个或多个可用时执行I/O操作。这种机制使得程序能够更高效地处理多个I/O操作。下面将对select的原理和工作机制进行详细介绍，并分析select函数的优势和局限。
文件I/O控制之select
伊伊_f
03-04 254
1.文件 I/O多路转接模型 在文件I/O控制之fcntl文章介绍了文件I/O阻塞的模式. 通过fcntl函数设置文件I/O为阻塞后,read/write函数对该文件操作时,如果条件不满足时(如串口没数据,那就一直等到有数据),read/write操作一直阻塞当前进程直到read/write操作完成.而在多路转接模型下,如果请求的I/O操作阻塞(如read操作阻塞),它只会让某个函数阻塞(如re...
IO多路复用——select
PANTAN_CSDN的博客
11-04 1226
Linux Socket网络编程——IO多路复用select
高级IO----select
wm12345645的博客
08-17 496
一，阻塞式IO 当需要执行一项任务，而且去执行这项任务必须要满足一个条件，如果在条件满足前一直等待，直到满足条件再去完成任务。 这种方式就是阻塞式 。 比如：一个人去钓鱼，没有鱼上钩就一直等待，直到有鱼上钩，下去拉鱼竿。 二，非阻塞式IO 当需要执行一项任务，而且去执行这项任务必须要满足一个条件，如果在条件满足前不等待 ，而是去干其他的事情，但要按时查看条件是否满足，直到满足条件再去完成...
pleinairisme.github.io:笔记
03-29
5. 表单处理：HTML用于创建用户交互的表单，使用`<form>`、`<input>`、`<textarea>`、`<select>`和`<button>`等元素。表单数据可以通过`method`属性设置的GET或POST方法提交到服务器。 6. 响应式设计：随着移动设备...
meegle.github.io：MeeGle的笔记
02-10
不仅如此，笔记可能还会涉及表单控件，如`<input>`、`<textarea>`、`<select>`和`<button>`，这些元素用于用户交互，收集和提交数据。表单可以配合`<form>`标签和属性如`action`（指定处理表单数据的服务器端脚本）...
IO复用之select分析笔记
weijitao的博客
11-01 577
对于一次IO访问，例如read操作，数据会先被拷贝到操作系统内核缓存区，然后才从操作系统内核缓存区拷贝到应用程序的地址空间。它会经历两个阶段： 1) 等待数据准备 2) 将数据拷贝到用户进程中 正是因为如此，Linux下面有5种IO模式 ◆阻塞型IO ◆非阻塞型IO ◆IO多路复用 ◆信号驱动 ◆异步IO 使用场景 IO复用是为了解决大量客户端访问问题而提出来的
Hansimov.github.io:我的技术笔记集锦
07-23
【Hansimov.github.io: 我的技术笔记集锦】是一个个人维基网站，由韩创建并维护，旨在分享他在IT领域的技术知识和经验。这个集合涵盖了多种IT相关的主题，尤其是与HTML相关的知识。HTML（超文本标记语言）是构建网页...
高级IO学习总结3—— select（）函数
SuGuolin的博客
11-21 501
原型 int select( int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, const struct timeval* timeout ); nfds：本参数忽略，仅起到兼容作用。    readfds：（可选）指针，指向一组等待可读性检查的套接口。    writefds：（可选）指针，指向一组等待可写
I/O模型 之Select 模型； Select管理TCP server
weixin_30505225的博客
03-18 150
一：Tcp Server 1: 当我们的Server接入一个客户端进来以后，就要管理好负责从客户端来接收数据，但是服务器要对多个客户端从不能一直等待这一个客户端有数据进来; 2: 我们的server还要读写数据，总不能一直等着有新的用户进来; 3: 需要一种方式来管理, select模型来管理我们的Tcp Server; 1> 创建一个句柄集合,这个集合里面有要管理的所有的socke...
高级IO-Select
学代码的咸鱼的博客
09-11 259
五种IO模型，Select服务器的编写
Virtex-6中的SelectIO模块
Reborn Lee
05-18 2502
SelectIO模块Virtex-6每个I/O片（I/O Tile）包含两个IOB、两个ILOGIC、两个OLOGIC 和两个IODELAY，如图5-24 所示。图5-24 I/O 片结构图本小节就以下几个方面介绍Virtex-6 的SelectIO 资源。(1) SelectIO 的电气特性。(2) SelectIO 的逻辑资源——ILOGIC 资源和OLOGIC 资源。(3) SelectIO...
IO复用之select
jiaomubai的博客
07-23 2056
select()函数和pselect()函数都用于用于IO复用，它们监视多个文件描述符的集合，判断是否有符合条件的事件发生。 select()函数与recv()函数和send()函数不同的是，recv()函数和send()函数可直接操作文件的描述符。但是使用select()函数时，需要先对所要操作的文件描述符进行查询，查看目标文件的描述符是否可以进行读、写、或...
SQL学习笔记六 union联合结果集使用
01-21
联合结果集 新建临时工数据表 代码如下: CREATE TABLE T_TempEmployee (FIdCardNumber VARCHAR(20),FName VARCHAR(20),FAge int,PRIMARY KEY(FIdCardNumber)); INSERT INTO T_TempEmployee(FIdCardNumber,FName,FAge...
IO——select 函数
tyustli
12-22 720
在调用 select 函数后，可以通过检查 readfds，writefds 和 exceptfds 集合的状态，以确定哪些文件描述符准备好进行 I/O 操作。然后，程序可以根据文件描述符的状态来执行相应的读、写或异常处理操作。它们都是由 fd_set 类型表示的位图结构。
IO多路复用——select()
六炅的专栏
03-11 372
IO多路复用总结1、基本概念IO多路复用的作用是允许应用同时在多个文件描述符上阻塞，并在其中某个可以读写时收到通知。因此，IO多路复用是应用的关键所在，在设计上遵循以下原则。 IO多路复用：当任何一个文件描述符IO就绪时进行通知。 都不可用？在有可用的文件描述符之前一直处于休眠状态。 唤醒：哪个文件描述符可用？ 处理所有IO就绪的文件描述符，没有阻塞。 返回第一步，重新开始。 IO多路复用适用如下场
网络io与select
weixin_52259848的博客
10-16 626
本次是对网络部分知识的内容再次复习学习，同期文章可以看上篇[Linux网络编程 ——Select机制](http://t.csdn.cn/qrcFV) 本文内容将以上课内容为导向，重新对其的学习。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值