本文详细介绍fcntl函数和select函数的使用方法。fcntl可用于设置文件描述符的属性，如非阻塞I/O，而select则用于监控多个文件描述符的状态变化，支持高效地处理多路I/O。文中还给出了具体的代码示例。
第一、fcntl函数详细使用
fcntl有强大的功能，它能够复制一个现有的描述符，获得/设置文件描述符标记，获得/设置文件状态标记，获得/设置异步I/O所有权，获得/设置纪录锁。
当多个用户共同使用，操作一个文件的情况，Linux通常采用的方法就是给文件上锁，来避免共享资源产生竞争的状态。
fcntl文件锁有两种类型：建议性锁和强制性锁
建议性锁是这样规定的：每个使用上锁文件的进程都要检查是否有锁存在，当然还得尊重已有的锁。内核和系统总体上都坚持不使用建议性锁，它们依靠程序员遵守这个规定。
强制性锁是由内核执行的。当文件被上锁来进行写入操作时，在锁定该文件的进程释放该锁之前，内核会阻止任何对该文件的读或写访问，每次读或写访问都得检查锁是否存在。
使用fcntl文件锁进行I/O操作必须小心：进程在开始任何I/O操作前如何去处理锁，在对文件解锁前如何完成所有的操作，是必须考虑的。如果在设置锁之前打开文件，或者读取该锁之后关闭文件，另一个进程就可能在上锁/解锁操作和打开/关闭操作之间的几分之一秒内访问该文件。当一个进程对文件加锁后，无论它是否释放所加的锁，只要文件关闭，内核都会自动释放加在文件上的建议性锁（这也是建议性锁和强制性锁的最大区别）, 所以不要想设置建议性锁来达到永久不让别的进程访问文件的目的(强制性锁才可以)^_^；强制性锁则对所有进程起作用。
可以用fcntl函数改变一个已打开的文件的属性,可以重新设置读、写、追加、非阻塞等标志(这些标志称为File StatusFlag),而不必重新open 文件。
#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd,long arg);
int fcntl(int fd, int cmd,struct flock *lock);
这个函数和open 一样,也是用可变参数实现的,可变参数的类型和个数取决于前面的cmd 参数。
文件锁包括了 建议性锁 和 强制性锁。
建议性锁要求每个上锁的文件的进程都要检查是否有锁存在，并且尊重已有的锁，在一般情况下，内核和系统都不使用建议性锁。
强制性锁是由内核执行的锁，当一个文件被上锁进行读写操作的时候，内核将阻止其他任何文件对其进行读写操作。每次读写操作都要检查是否有锁存在。
在Linux中实现上锁的函数有lock()和fcntl()。
lock()用于对文件施加建议性锁
fcntl()用于对文件施加建议性锁和强制性锁都行。同时还可以对文件某一条纪录进行上锁，也就是记录锁。
记录锁分为 读取锁（共享锁，它能够使多个进程都能在文件的同一部分建立读取锁） 和 写入锁（排斥锁，在任何时刻只能有一个进程在文件的某部分建立写入锁。）。
fcntl函数原型
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
int fcntl(intfd, //文件描述符
int cmd , //不同的命令
struct flock *lock) //设置记录锁的具体状态
cmd取值：
F_DUPFD 复制文件描述符
F_GETFD 获得fd的close-on-exec标志
F_SETFD 设置close-on-exec标志
F_GETFL 获得open设置标志
F_SETFL 设置lock描述的标志
F_GETLK 测试该锁是否被另外一把锁排斥
F_SETLKW 如果存在其他锁，则调用进程睡眠，如果捕捉到信号则睡眠中断
F_GETOWN 检索收到的SIGIO和SIGURG信号的进程号或者进程组号
F_SETOWN 设置进程号或进程组号
这里的lock结构体如下：
struct flock
{
short l_type; /*F_RDLCK(读取锁),F_WRLCK（写入锁）,F_UNLCK（解锁）*/
off_t l_start; /*相对偏移量（字节）*/
short l_whence; /*SEEK_SET ,SEEK_CUR ,SEEK_END */
off_t l_len; /*加锁区域长度*/
pid_t l_pid;
}
成功：0
出错：-1
提示：如果加锁整个文件通常的方法是将l_start设置为0，l_whence设置为SEEK_SET, l_len设置为0。
下面的例子使用F_GETFL和F_SETFL这两种fcntl命令改变STDIN_FILENO的属性上O_NONBLOCK 选项,实现非阻塞读终端的功能。
用fcntl改变File Status Flag
#include <unistd.h>
#include <fcntl.h>
#include<errno.h>
#include <string.h>
#include <stdlib.h>
#define MSG_TRY "try again\n"
intmain(void)
{
char buf[10];
int n;
int flags;
flags = fcntl(STDIN_FILENO, F_GETFL);
flags |= O_NONBLOCK;
if (fcntl(STDIN_FILENO, F_SETFL, flags) == -1)
{
perror("fcntl");
exit(1);
}
tryagain:
n = read(STDIN_FILENO, buf, 10);
if (n < 0)
{
if (errno == EAGAIN)
{
sleep(1);
write(STDOUT_FILENO, MSG_TRY,strlen(MSG_TRY));
goto tryagain;
}
perror("read stdin");
exit(1);
}
write(STDOUT_FILENO, buf, n);
return 0;
}
第二、select函数详细使用
select系统调用是用来让我们的程序监视多个文件句柄(filedescriptor)的状态变化的。程序会停在select这里等待，直到被监视的文件句柄有某一个或多个发生了状态改变。
文件在句柄在Linux里很多，如果你man某个函数，在函数返回值部分说到成功后有一个文件句柄被创建的都是的，如man socket可以看到“On success, a file descriptor for the new socket isreturned.”而man 2 open可以看到“open() and creat()return the new file descriptor”，其实文件句柄就是一个整数，看socket函数的声明就明白了：
intsocket(int domain, int type, int protocol);
当然，我们最熟悉的句柄是0、1、2三个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、stdout、stderr，0就是stdin，1就是stdout，2就是stderr。
比如下面这两段代码都是从标准输入读入9个字节字符：
#include<stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char ** argv)
{
char buf[10] = "";
read(0, buf, 9); /* 从标准输入 0 读入字符 */
fprintf(stdout, "%s\n",buf); /* 向标准输出 stdout 写字符 */
return 0;
}
/* **上面和下面的代码都可以用来从标准输入读用户输入的9个字符** */
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char ** argv)
{
char buf[10] = "";
fread(buf, 9, 1, stdin); /* 从标准输入 stdin 读入字符 */
write(1, buf, strlen(buf));
return 0;
}
继续上面说的select，就是用来监视某个或某些句柄的状态变化的。select函数原型如下：
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set*exceptfds, struct timeval *timeout);
函数的最后一个参数timeout显然是一个超时时间值，其类型是struct timeval *，即一个structtimeval结构的变量的指针，所以我们在程序里要申明一个struct timeval tv;然后把变量tv的地址&tv传递给select函数。struct timeval结构如下：
|
struct timeval { |
第2、3、4三个参数是一样的类型： fd_set *，即我们在程序里要申明几个fd_set类型的变量，比如rdfds, wtfds, exfds，然后把这个变量的地址&rdfds, &wtfds,&exfds 传递给select函数。这三个参数都是一个句柄的集合，第一个rdfds是用来保存这样的句柄的：当句柄的状态变成可读的时系统就会告诉select函数返回，同理第二个wtfds是指有句柄状态变成可写的时系统就会告诉select函数返回，同理第三个参数exfds是特殊情况，即句柄上有特殊情况发生时系统会告诉select函数返回。特殊情况比如对方通过一个socket句柄发来了紧急数据。如果我们程序里只想检测某个socket是否有数据可读，我们可以这样：
|
fd_set rdfds; /* 先申明一个 fd_set 集合来保存我们要检测的 socket句柄 */ |
注意select函数的第一个参数，是所有加入集合的句柄值的最大那个值还要加1。比如我们创建了3个句柄：
/************关于本文档********************************************
*filename: Linux网络编程一步一步学-select详解
*purpose: 详细说明select的用法
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2007-02-03 19:40
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to:Google
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int sa, sb, sc;
sa = socket(...); /* 分别创建3个句柄并连接到服务器上 */
connect(sa,...);
sb = socket(...);
connect(sb,...);
sc = socket(...);
connect(sc,...);
FD_SET(sa, &rdfds);/* 分别把3个句柄加入读监视集合里去 */
FD_SET(sb, &rdfds);
FD_SET(sc, &rdfds);
在使用select函数之前，一定要找到3个句柄中的最大值是哪个，我们一般定义一个变量来保存最大值，取得最大socket值如下：
|
int maxfd = 0; |
然后调用select函数：
ret = select(maxfd + 1, &rdfds, NULL, NULL, &tv); /* 注意是最大值还要加1 */
同样的道理，如果我们要检测用户是否按了键盘进行输入，我们就应该把标准输入0这个句柄放到select里来检测，如下：
|
FD_ZERO(&rdfds); |
linuxsocket网络编程：fcntl select（多个客户端连接服务器端情形）
一、引言
在实际情况中，人们往往遇到多个客户端连接服务器端的情况。由于之前介绍的函数如connect,recv,send等都是阻塞性函数，若资源没有充分准备好，则调用该函数的进程将进入睡眠状态，这样就无法处理I/O多路复用的情况了。
本文给出两种I/O多路复用的方法：fcntl(),select()。可以看到，由于Linux中把socket当作一种特殊的文件描述符，这给用户的处理带来很大方便。
二、fcntl
fcntl()函数有如下特性：
1）非阻塞I/O：可将cmd 设为F_SETFL,将lock设为O_NONBLOCK
2)信号驱动I/O：可将cmd设为F_SETFL,将lock设为O_ASYNC.
例程：
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/un.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#define SERVPORT 3333
#define BACKLOG 10
#define MAX_CONNECTED_NO 10
#define MAXDATASIZE 100
int main()
{
structsockaddr_in server_sockaddr,client_sockaddr;
intsin_size,recvbytes,flags;
intsockfd,client_fd;
charbuf[MAXDATASIZE];
/*创建socket*/
if((sockfd= socket(AF_INET,SOCK_STREAM,0))==-1){
perror("socket");
exit(1);
}
printf("socketsuccess!,sockfd=%d\n",sockfd);
/*设置sockaddr结构*/
server_sockaddr.sin_family=AF_INET;
server_sockaddr.sin_port=htons(SERVPORT);
server_sockaddr.sin_addr.s_addr=INADDR_ANY;
bzero(&(server_sockaddr.sin_zero),8);
/*将本地ip地址绑定端口号*/
if(bind(sockfd,(structsockaddr *)&server_sockaddr,sizeof(struct sockaddr))==-1){
perror("bind");
exit(1);
}
printf("bindsuccess!\n");
/*监听*/
if(listen(sockfd,BACKLOG)==-1){
perror("listen");
exit(1);
}
printf("listening....\n");
/*fcntl()函数，处理多路复用I/O*/
if((flags=fcntl(sockfd, F_SETFL, 0))<0)
perror("fcntlF_SETFL");
flags|= O_NONBLOCK;
if(fcntl(sockfd, F_SETFL,flags)<0)
perror("fcntl");
while(1){
sin_size=sizeof(structsockaddr_in);
if((client_fd=accept(sockfd,(structsockaddr*)&client_sockaddr,&sin_size))==-1){ //服务器接受客户端的请求，返回一个新的文件描述符
perror("accept");
exit(1);
}
if((recvbytes=recv(client_fd,buf,MAXDATASIZE,0))==-1){
perror("recv");
exit(1);
}
if(read(client_fd,buf,MAXDATASIZE)<0){
perror("read");
exit(1);
}
printf("receiveda connection :%s",buf);
/*关闭连接*/
close(client_fd);
exit(1);
}/*while*/
}
运行该程序：
[root@localhostnet]# ./fcntl
socketsuccess!,sockfd=3
bind success!
listening....
accept: Resourcetemporarily unavailable
可以看到，当accept的资源不可用时，程序会自动返回。
若将红色加粗代码替换为：
if((flags=fcntl(sockfd, F_SETFL, 0))<0)
perror("fcntl F_SETFL");
flags |= O_ASYNC;
if(fcntl( sockfd,F_SETFL,flags)<0)
perror("fcntl");
运行结果如下：
[root@localhostnet]# ./fcntl1
socketsuccess!,sockfd = 3
bind success!
listening...
可以看到，进程一直处于等待中，直到另一相关信号驱动它为止。
三、select
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/wait.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/un.h>
#include<sys/time.h>
#include<sys/ioctl.h>
#include <unistd.h>
#include<netinet/in.h>
#define SERVPORT3333
#define BACKLOG 10
#defineMAX_CONNECTED_NO 10
#defineMAXDATASIZE 100
int main()
{
struct sockaddr_inserver_sockaddr,client_sockaddr;
int sin_size,recvbytes;
fd_set readfd;
fd_set writefd;
int sockfd,client_fd;
char buf[MAXDATASIZE];
/*创建socket*/
if((sockfd =socket(AF_INET,SOCK_STREAM,0))==-1){
perror("socket");
exit(1);
}
printf("socketsuccess!,sockfd=%d\n",sockfd);
/*设置sockaddr结构*/
server_sockaddr.sin_family=AF_INET;
server_sockaddr.sin_port=htons(SERVPORT);
server_sockaddr.sin_addr.s_addr=INADDR_ANY;
bzero(&(server_sockaddr.sin_zero),8);
/*将本地ip地址绑定端口号*/
if(bind(sockfd,(struct sockaddr*)&server_sockaddr,sizeof(struct sockaddr))==-1){
perror("bind");
exit(1);
}
printf("bind success!\n");
/*监听*/
if(listen(sockfd,BACKLOG)==-1){
perror("listen");
exit(1);
}
printf("listening....\n");
/*select*/
FD_ZERO(&readfd); // 将readfd 清空
FD_SET(sockfd,&readfd); //将sockfd加入到readfd集合中
while(1){
sin_size=sizeof(struct sockaddr_in);
if(select(MAX_CONNECTED_NO,&readfd,NULL,NULL,(structtimeval *)0)>0){ //第一个参数是0和sockfd的最大值加1，第二个参数是读集，第三、四个参数是写集 //和异常集
if(FD_ISSET(sockfd,&readfd)>0){ // FD_ISSET 这个宏判断 sockfd 是否属于可读的文件描述符。从 sockfd 中读入, 输出到标准输出上去.
if((client_fd=accept(sockfd,(structsockaddr *)&client_sockaddr,&sin_size))==-1){ //client_sockaddr：客户端地址
perror("accept");
exit(1);
}
if((recvbytes=recv(client_fd,buf,MAXDATASIZE,0))==-1){
perror("recv");
exit(1);
}
if(read(client_fd,buf,MAXDATASIZE)<0){
perror("read");
exit(1);
}
printf("received aconnection :%s",buf);
}/*if*/
close(client_fd);
}/*select*/
}/*while*/
}
运行结果如下：
[root@localhostnet]# gcc select1.c -o select1
[root@localhostnet]# ./select1
socket createsuccess!
bind success!
listening...
深入UNIX编程:一个简单聊天室的两种实现 (fcntl 和 select)
在互联网相当普及的今天，在互联网上聊天对很多“网虫”来说已经是家常便饭了。聊天室程序可以说是网上最简单的多点通信程序。聊天室的实现方法有很多，但都是利用所谓的“多用户空间”来对信息进行交换，具有典型的多路I/O的架构。一个简单的聊天室, 从程序员的观点来看就是在多个I/O端点之间实现多对多的通信。其架构如图一所示。这样的实现在用户的眼里就是聊天室内任何一个人输入一段字符之后,其他用户都可以得到这一句话。这种“多用户空间”的架构在其他多点通信程序中应用的非常广泛，其核心就是多路I/O通信。多路I/O通信又被称为I/O多路复用（I/O Multiplexing）一般被使用在以下的场合：
客户程序需要同时处理交互式的输入和同服务器之间的网络连接时需要处理I/O多路复用问题；
客户端需要同时对多个网络连接作出反应（这种情况很少见）；
TCP服务器需要同时处理处于监听状态和多个连接状态的socket；
服务器需要处理多个网络协议的socket;
服务器需要同时处理不同的网络服务和协议。
聊天室所需要面对的情况正是第一和第三两种情况。我们将通过在TCP/IP协议之上建立一个功能简单的聊天室让大家更加了解多路I/O以及它的实现方法。我们要讨论的聊天室功能非常简单, 感兴趣的朋友可以将其功能扩展, 发展成一个功能比较完整的聊天室, 如加上用户认证, 用户昵称, 秘密信息, semote 等功能. 首先它是一个 client/server 结构的程序, 首先启动server, 然后用户使用client 进行连接.client/server 结构的优点是速度快, 缺点是当 server 进行更新时, client 也必需更新.
网络初始化
首先是初始化server, 使server 进入监听状态: (为了简洁起见,以下引用的程序与实际程序略有出入, 下同)
sockfd = socket( AF_INET,SOCK_STREAM, 0);
// 首先建立一个 socket, 族为AF_INET, 类型为 SOCK_STREAM.
// AF_INET = ARPA Internet protocols 即使用 TCP/IP 协议族
// SOCK_STREAM 类型提供了顺序的, 可靠的, 基于字节流的全双工连接.
// 由于该协议族中只有一个协议, 因此第三个参数为 0
bind( sockfd, ( struct sockaddr *)&serv_addr, sizeof( serv_addr));
// 再将这个socket 与某个地址进行绑定.
// serv_addr 包括sin_family = AF_INET 协议族同socket
// sin_addr.s_addr = htonl( INADDR_ANY) server 所接受的所有其他
// 地址请求建立的连接.
// sin_port = htons( SERV_TCP_PORT) server 所监听的端口
// 在本程序中, server 的 IP和监听的端口都存放在config 文件中.
listen( sockfd, MAX_CLIENT);
// 地址绑定之后,server 进入监听状态.
// MAX_CLIENT 是可以同时建立连接的 client总数.
server 进入 listen 状态后, 等待 client 建立连接。
Client端要建立连接首先也需要初始化连接：
sockfd = socket( AF_INET,SOCK_STREAM,0));
// 同样的,client 也先建立一个 socket, 其参数与 server 相同.
connect( sockfd, ( struct sockaddr *)&serv_addr, sizeof( serv_addr));
// client 使用 connect建立一个连接.
// serv_addr 中的变量分别设置为:
// sin_family = AF_INET 协议族同socket
// sin_addr.s_addr = inet_addr( SERV_HOST_ADDR) 地址为server
// 所在的计算机的地址.
// sin_port = htons( SERV_TCP_PORT) 端口为 server 监听的端口.
当 client 建立新连接的请求被送到Server端时,server 使用 accept 来接受该连接:
accept( sockfd, (struct sockaddr*)&cli_addr, &cli_len);
// 在函数返回时,cli_addr 中保留的是该连接对方的信息
// 包括对方的 IP 地址和对方使用的端口.
// accept 返回一个新的文件描述符.
在 server 进入 listen 状态之后, 由于已有多个用户在线，所以程序需要同时对这些用户进行操作，并在它们之间实现信息交换。这在实现上称为I/O多路复用技术。多路复用一般有以下几种方法：
非阻塞通信方法：将文件管道通过fcntl()设为非阻塞通信方式，每隔一端时间对他们实行一次轮询，以判断是否可以进行读写操作。这种方式的缺点是费用太高，大部分资源浪费在轮询上。
子进程方法：应用多个子进程，每一个对一个单工阻塞方式通信。所有子进程通过IPC和父进程进行通信。父进程掌管所有信息。这种方式的缺点是实现复杂，而且由于IPC在各个操作系统平台上并不完全一致，会导致可移植性降低。
信号驱动（SIGIO）的异步I/O方法：首先，异步I/O是基于信号机制的，并不可靠。其次单一的信号不足以提供更多的信息来源。还是需要辅助以其他的手段，实现上有很高的难度。
select ()方法：在BSD中提供了一种可以对多路I/O进行阻塞式查询的方法——select()。它提供同时对多个I/O描述符进行阻塞式查询的方法，利用它，我们可以很方便的实现多路复用。根据统一UNIX规范的协议,POSIX也采用了这种方法，因此，我们可以在大多数操作系统中使用select方法。
使用专门的I/O多路复用器：在“UNIX? SYSTEM V Programmer's Guide:STREAMS”一书中详细的说明了构造和使用多路复用器的方法。这里就不再详述了。
我们下面分别讨论多路I/O的两种实现方法:
1. 非阻塞通信方法
对一个文件描述符指定的文件或设备, 有两种工作方式: 阻塞与非阻塞。所谓阻塞方式的意思是指, 当试图对该文件描述符进行读写时, 如果当时没有东西可读,或者暂时不可写, 程序就进入等待状态, 直到有东西可读或者可写为止。而对于非阻塞状态, 如果没有东西可读, 或者不可写, 读写函数马上返回, 而不会等待。缺省情况下, 文件描述符处于阻塞状态。在实现聊天室时, server 需要轮流查询与各client 建立的 socket, 一旦可读就将该 socket 中的字符读出来并向所有其他client 发送。并且, server 还要随时查看是否有新的 client 试图建立连接,这样, 如果 server 在任何一个地方阻塞了, 其他 client 发送的内容就会受到影响,得不到服务器的及时响应。新 client 试图建立连接也会受到影响。所以我们在这里不能使用缺省的阻塞的文件工作方式，而需要将文件的工作方式变成非阻塞方式。在UNIX下，函数fcntl()可以用来改变文件I/O操作的工作方式，函数描述如下：
fcntl( sockfd, F_SETFL, O_NONBLOCK);
// sockfd 是要改变状态的文件描述符.
//F_SETFL 表明要改变文件描述符的状态
// O_NONBLOCK 表示将文件描述符变为非阻塞的.
为了节省篇幅我们使用自然语言描述聊天室server :
while ( 1)
{
if 有新连接 then 建立并记录该新连接;
for ( 所有的有效连接)
begin
if 该连接中有字符可读 then
begin
读入字符串；
for ( 所有其他的有效连接)
begin
将该字符串发送给该连接;
end;
end;
end;
end.
由于判断是否有新连接, 是否可读都是非阻塞的, 因此每次判断,不管有还是没有, 都会马上返回. 这样,任何一个 client 向server 发送字符或者试图建立新连接, 都不会对其他 client 的活动造成影响。
对client 而言, 建立连接之后, 只需要处理两个文件描述符, 一个是建立了连接的 socket 描述符, 另一个是标准输入. 和 server 一样, 如果使用阻塞方式的话, 很容易因为其中一个暂时没有输入而影响另外一个的读入.. 因此将它们都变成非阻塞的, 然后client 进行如下动作:
while ( 不想退出)
begin
if ( 与server 的连接有字符可读)
begin
从该连接读入, 并输出到标准输出上去.
End;
if ( 标准输入可读)
Begin
从标准输入读入, 并输出到与server 的连接中去.
End;
End.
上面的读写分别调用这样两个函数:
read( userfd, line, MAX_LINE);
// userfd 是指第 i 个 client 连接的文件描述符.
// line 是指读出的字符存放的位置.
// MAX_LINE 是一次最多读出的字符数.
// 返回值是实际读出的字符数.
write( userfd[j], line, strlen( line));
// userfd[j] 是第 j 个 client 的文件描述符.
// line 是要发送的字符串.
// strlen( line) 是要发送的字符串长度.
分析上面的程序可以知道, 不管是 server 还是 client, 它们都不停的轮流查询各个文件描述符, 一旦可读就读入并进行处理. 这样的程序, 不停的在执行, 只要有CPU 资源, 就不会放过。因此对系统资源的消耗非常大。server或者 client 单独执行时, CPU 资源的 98% 左右都被其占用。极大的消耗了系统资源。
2、select 方法
因此，虽然我们不希望在某一个用户没有反应时阻塞其他的用户，但我们却应该在没有任何用户有反应的情况之下停止程序的运行，让出抢占的系统资源，进入阻塞状态。有没有这种方法呢？现在的UNIX系统中都提供了select方法，具体实现方式如下：
select 方法中, 所有文件描述符都是阻塞的. 使用 select 判断一组文件描述符中是否有一个可读(写), 如果没有就阻塞, 直到有一个的时候就被唤醒. 我们先看比较简单的 client 的实现:
由于 client 只需要处理两个文件描述符, 因此, 需要判断是否有可读写的文件描述符只需要加入两项:
FD_ZERO( sockset);
// 将 sockset 清空
FD_SET( sockfd, sockset);
// 把 sockfd 加入到 sockset 集合中
FD_SET( 0, sockset);
// 把 0 (标准输入) 加入到 sockset 集合中
然后 client 的处理如下:
while ( 不想退出)
{
select( sockfd 1, &sockset, NULL, NULL, NULL);
// 此时该函数将阻塞直到标准输入或者 sockfd 中有一个可读为止
// 第一个参数是 0 和 sockfd 中的最大值加一
// 第二个参数是读集, 也就是 sockset
// 第三, 四个参数是写集和异常集, 在本程序中都为空
// 第五个参数是超时时间, 即在指定时间内仍没有可读, 则出错
// 并返回. 当这个参数为NULL 时, 超时时间被设置为无限长.
// 当 select 因为可读返回时, sockset 中包含的只是可读的
// 那些文件描述符.
if ( FD_ISSET( sockfd, &sockset))
{
// FD_ISSET 这个宏判断sockfd 是否属于可读的文件描述符
从 sockfd 中读入, 输出到标准输出上去.
}
if ( FD_ISSET( 0, &sockset))
{
// FD_ISSET 这个宏判断sockfd 是否属于可读的文件描述符
从标准输入读入, 输出到 sockfd 中去.
}
重新设置 sockset. (即将 sockset 清空, 并将 sockfd 和 0 加入)
}
下面看 server 的情况:
设置 sockset 如下:
FD_ZERO( sockset);
FD_SET( sockfd, sockset);
for ( 所有有效连接)
FD_SET( userfd, sockset);
}
maxfd = 最大的文件描述符号 1;
server 处理如下:
while ( 1)
{
select( maxfd, &sockset, NULL, NULL, NULL);
if ( FD_ISSET( sockfd, &sockset))
{
// 有新连接
建立新连接, 并将该连接描述符加入到sockset 中去了.
}
for ( 所有有效连接)
{
if ( FD_ISSET ( userfd, &sockset))
{
// 该连接中有字符可读
从该连接中读入字符, 并发送到其他有效连接中去.
}
}
重新设置 sockset;
}
性能比较
由于采用select 机制, 因此当没有字符可读时, 程序处于阻塞状态,最小程度的占用CPU 资源, 在同一台机器上执行一个server 和若干个client时, 系统负载只有 0.1 左右, 而采用原来的非阻塞通信方法, 只运行一个 server, 系统负载就可以达到 1.5 左右. 因此我们推荐使用select.
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
