select用法详解

最新推荐文章于 2023-05-07 21:09:53 发布

xiaocuancuan

最新推荐文章于 2023-05-07 21:09:53 发布

阅读量843

点赞数

分类专栏：服务器编程 Unix/Linux 文章标签： unix select 性能

本文链接：https://blog.youkuaiyun.com/hualicuan/article/details/19620195

版权

Unix/Linux 同时被 2 个专栏收录

30 篇文章

订阅专栏

服务器编程

18 篇文章

订阅专栏

select函数的C API版本是这样的：

int select( int width,//最大句柄数加1

fd_set *read_fds,//监视的可读文件句柄集合。

fd_set *write_fds,//监视的可写文件句柄集合。

fd_set*excepr_fds,//监视的异常文件句柄集合。

struct timeval *timeout);本次select()的超时结束时间。（见/usr/sys/select.h, 可精确至百万分之一秒！）

select函数的作用：

select()的机制中提供一fd_set的数据结构，实际上是一long类型的数组，
每一个数组元素都能与一打开的文件句柄（不管是Socket句柄,还是其他
文件或命名管道或设备句柄）建立联系，建立联系的工作由程序员完成，
当调用select()时，由内核根据IO状态修改fd_set的内容，由此来通知执
行了select()的进程哪一Socket或文件可读。

当readfds或writefds中映象的文件可读或可写或超时，本次select()
就结束返回。程序员利用一组系统提供的宏在select()结束时便可判
断哪一文件可读或可写。对Socket编程特别有用的就是readfds。

下面是一组宏：

FD_ISSET(int fd, fd_set *set);//检查fdset联系的文件句柄fd是否可读写，>0表示可读写。

FD_SET(int fd, fd_set *set);//建立某个文件句柄fd与fdset的联系。

FD_CLR(int fd, fd_set *set);//清除某个文件句柄fd与fdset的联系。

FD_ZERO(fd_set *set);//清空fdset与所有文件句柄的联系。

（关于fd_set及相关宏的定义见/usr/include/sys/types.h）

返回值：

如果函数超时,未发现有套接字活动的,返回0;
函数执行错误,返回-1;
如果有套接字活动,返回套接字的数量;

有时，select()也被用来当作延时函数使用。sleep()延时会释放cpu，用select的话，可以在占用cpu的情况下延时。

select()函数主要用于查询“文件”的“状态”。

select()的机制中提供一fd_set的数据结构，实际上是一long类型的数组，每一个数组元素都能与一打开的文件句柄建立联系（不管是Socket句柄,还是其他文件或命名管道或设备句柄）。
当调用select()时，由内核根据IO状态修改fd_set的内容，由此来通知执行了select()的进程哪一Socket或文件可读。

select()函数作为I/O复用时,如果其超时值设为0,则立即返回,即处于 polling模式,程序对select进行"轮询",一般认为这样会对性能有影响,请问,会有什么样的影响?我做了试验,我把超时值设为1秒,我发现这两种情况下程序的速度没什么变化,那么到底超时值为0对程序会有什么样的影响?为什么设定一个超时值就可以避免对CPU时间的浪费呢?谢谢!

如果你的进程不停的接到数据，当然就看不出区别了。都马上返回

如果不忙的话，你不停的轮询一直占用cpu。而设置超时，在等待的时候，
进程阻塞，cpu资源就可以空闲给其它的进程用了。

select如果处于轮询状态，就相当于不停的在问“有数据了吗？”，你的程序可是要靠cpu来运行的；而处于阻塞状态的时候，就相当于睡觉，有数据的时候，其它“人”会告诉它“喂，数据来了，快处理吧”，你的select就返回了，ok？

select()--多路同步 I/O

虽然这个函数有点奇怪，但是他很有用。假设这样的情况：你是个服务器，你一边在不停地从连接上读数据，一边在侦听连接上的信息。

没问题，你可能会说，不就是一个 accept() 和两个 recv() 吗? 这么容易吗，朋友? 如果你在调用 accept() 的时候阻塞呢? 你怎么能够同时接受 recv() 数据? "用非阻塞的套接口啊！" 不行！你不想耗尽所有的 CPU，不是吗? 那么，该如何是好?

select() 让你可以同时监视多个套接口。如果你想知道的话，那么他就会告诉你哪个套接口准备读，哪个又准备好了写，哪个套接口又发生了例外 (exception)。

闲话少说，下面是 select()：

       #include <sys/time.h>
       #include <sys/types.h>
       #include <unistd.h>

       int select(int numfds, fd_set*readfds, fd_set *writefds,
                fd_set *exceptfds, structtimeval *timeout);

这个函数监视一系列文件描述符，特别是 readfds、writefds 和 exceptfds。如果你想知道你是否能够从标准输入和套接口描述符 sockfd 读入数据，你只要将文件描述符 0 和 sockfd 加入到集合 readfds 中。参数 numfds 应该等于最高的文件描述符的值加1。在这个例子中，你应该设置该值为 sockfd+1。因为他一定大于标准输入的文件描述符 (0)。

当函数 select() 返回的时候，readfds 的值修改为反映你选择的哪个文件描述符可以读。你可以用下面讲到的宏 FD_ISSET() 来测试。

在我们继续下去之前，让我来讲讲如何对这些集合进行操作。每个集合类型都是 fd_set。下面有一些宏来对这个类型进行操作：

· FD_ZERO(fd_set*set) - clears a file descriptor set

· FD_SET(intfd, fd_set *set) - adds fd to the set

· FD_CLR(intfd, fd_set *set) - removes fd from the set

· FD_ISSET(intfd, fd_set *set) - tests tosee if fd is in the set

最后，是有点古怪的数据结构 structtimeval。有时你可不想永远等待别人发送数据过来。也许什么事情都没有发生的时候你也想每隔96秒在终端上打印字符串 "Still Going..."。这个数据结构允许你设定一个时间，如果时间到了，而 select() 还没有找到一个准备好的文件描述符，他将返回让你继续处理。

数据结构 structtimeval 是这样的：

    struct timeval {
        int tv_sec;     /* seconds */
        int tv_usec;    /* microseconds */
    };

只要将 tv_sec 设置为你要等待的秒数，将 tv_usec 设置为你要等待的微秒数就可以了。是的，是微秒而不是毫秒。1,000微秒等于1豪秒，1,000毫秒等于1秒。也就是说，1秒等于1,000,000微秒。为什么用符号 "usec" 呢? 字母 "u" 很象希腊字母 Mu，而 Mu 表示 "微"的意思。当然，函数返回的时候 timeout 可能是剩余的时间，之所以是可能，是因为他依赖于你的 Unix 操作系统。

哈！我们现在有一个微秒级的定时器！不要计算了，标准的 Unix 系统的时间片是100毫秒，所以无论你如何设置你的数据结构 structtimeval，你都要等待那么长的时间。

还有一些有趣的事情：如果你设置数据结构 structtimeval 中的数据为 0，select() 将立即超时，这样就可以有效地轮询集合中的所有的文件描述符。如果你将参数 timeout 赋值为 NULL，那么将永远不会发生超时，即一直等到第一个文件描述符就绪。最后，如果你不是很关心等待多长时间，那么就把他赋为 NULL 吧。

下面的代码演示了在标准输入上等待 2.5 秒：

       #include <sys/time.h>
       #include <sys/types.h>
       #include <unistd.h>

       #define STDIN 0 /* file descriptor for standard input */

       main()
       {
           struct timeval tv;
           fd_set readfds;

           tv.tv_sec = 2;
           tv.tv_usec = 500000;

         FD_ZERO(&readfds);
           FD_SET(STDIN, &readfds);

           /* don't care about writefdsand exceptfds: */
           select(STDIN+1, &readfds,NULL, NULL, &tv);

           if (FD_ISSET(STDIN,&readfds))
               printf("A key was pressed!\n");
           else
               printf("Timedout.\n");
       }

如果你是在一个 line buffered 终端上，那么你敲的键应该是回车 (RETURN)，否则无论如何他都会超时。

现在，你可能回认为这就是在数据报套接口上等待数据的方式--你是对的：他可能是。有些 Unix 系统可以按这种方式，而另外一些则不能。你在尝试以前可能要先看看本系统的 man page 了。

最后一件关于 select() 的事情：如果你有一个正在侦听 (listen()) 的套接口，你可以通过将该套接口的文件描述符加入到 readfds 集合中来看是否有新的连接。

这就是我关于函数 select() 要讲的所有的东西。

例子

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/* port we're listening on */
#define PORT 2020

int main(int argc, char *argv[])
{
	/*定义描述符集合 */
	fd_set master;
	/* 定义select函数可读的描述符*/
	fd_set read_fds;
	/* 服务器地址 */
	struct sockaddr_in serveraddr;
	/* 客户地址 */
	struct sockaddr_in clientaddr;
	/* 定义最大描述符数 */
	int fdmax;
	/* 监听描述符 */
	int listener;
	/* accept描述符 */
	int newfd;
	/* 缓冲 */
	char buf[1024];
	int nbytes;
	/* 设置 setsockopt() SO_REUSEADDR */
	int yes = 1;
	int addrlen;
	int i, j;
	/* 清除 */
	FD_ZERO(&master);
	FD_ZERO(&read_fds);

	/* 连接 */
	if((listener = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	{
		perror("Server-socket() error lol!");

		exit(1);
	}
	printf("Server-socket() is OK...\n");
	/*判断地址以用 */
	if(setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
	{
		perror("Server-setsockopt() error lol!");
		exit(1);
	}
	printf("Server-setsockopt() is OK...\n");

	/* bind */
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_addr.s_addr = INADDR_ANY;
	serveraddr.sin_port = htons(PORT);
	memset(&(serveraddr.sin_zero), '\0', 8);

	if(bind(listener, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) == -1)
	{
		perror("Server-bind() error lol!");
		exit(1);
	}
	printf("Server-bind() is OK...\n");

	/* listen */
	if(listen(listener, 10) == -1)
	{
		perror("Server-listen() error lol!");
		exit(1);
	}
	printf("Server-listen() is OK...\n");

	/* 把 listener 加到 master set */
	FD_SET(listener, &master);

	/* keep track of the biggest file descriptor */
	fdmax = listener; /* so far, it's this one*/

	/* 循环了 */
	for(;;)
	{
		/* copy it */
		read_fds = master;

		if(select(fdmax+1, &read_fds, NULL, NULL, NULL) == -1)
		{
			perror("Server-select() error lol!");
			exit(1);
		}
		printf("Server-select() is OK...\n");

		/*从存在的描述符中查找要读的数据*/
		for(i = 0; i <= fdmax; i++)
		{
			if(FD_ISSET(i, &read_fds))
			{ /* 得到一个... */
				if(i == listener)
				{
					/* h处理这个的连接 */
					addrlen = sizeof(clientaddr);
					if((newfd = accept(listener, (struct sockaddr *)&clientaddr, &addrlen)) == -1)
					{
						perror("Server-accept() error lol!");
					}
					else
					{
						printf("Server-accept() is OK...\n");

						FD_SET(newfd, &master); /* add to master set */
						if(newfd > fdmax)
						{ /* keep track of the maximum */
							fdmax = newfd;
						}
						printf("%s: New connection from %s on socket %d\n", argv[0], inet_ntoa(clientaddr.sin_addr), newfd);
					}
				}
				else
				{
					/* 处理从客户端来的数据*/
					if((nbytes = recv(i, buf, sizeof(buf), 0)) <= 0)
					{
						/* 没有数据 */
						if(nbytes == 0)
							/* 断开连接。 */
							printf("%s: socket %d hung up\n", argv[0], i);

						else
							perror("recv() error lol!");

						/* 关闭... */
						close(i);
						/* 删除这个连接符 */
						FD_CLR(i, &master);
					}
					else
					{
						/* we got some data from a client*/
						for(j = 0; j <= fdmax; j++)
						{
							/* 发给每个人! */
							if(FD_ISSET(j, &master))
							{
								/* 除了监听的和自己的。 */
								if(j != listener && j != i)
								{
									if(send(j, buf, nbytes, 0) == -1)
										perror("send() error lol!");
								}
							}
						}
					}
				}
			}
		}
	}
	return 0;
}