select用法详解

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;
}