套接字I/O模型 请教

[DeadWolf]

在windows的socket编程有
select模型， WSAAsyncSelect ，WSAEventSelect ， 重叠模型，完成端口模型
等几种IO模型

特别是重叠模型，完成端口模型基本指针对
服务器在任何给定的时间，都会有大量的处理，简单点就是说在性能上得到提高。

但是看了一下linux下面的网络编程，好像没有这方面的介绍
本人初学，可能孤陋寡闻了

[iintsy]

一、理论说明
聊天室程序可以说是网上最简单的多点通信程序。聊天室的实现方法有很多，但都是利用所谓的"多用户空间"来对信息进行交换，具有典型的多路I/O的架构。一个简单的聊天室， 从程序员的观点来看就是在多个I/O端点之间实现多对多的通信。其架构如图一所示。这样的实现在用户的眼里就是聊天室内任何一个人输入一段字符之后，其他用户都可以得到这一句话。这种"多用户空间"的架构在其他多点通信程序中应用的非常广泛，其核心就是多路I/O通信。多路I/O通信又被称为I/O多路复用（I/O Multiplexing）一般被使用在以下的场合：
客户程序需要同时处理交互式的输入和同服务器之间的网络连接时需要处理I/O多路复用问题；
客户端需要同时对多个网络连接作出反应（这种情况很少见）；
TCP服务器需要同时处理处于监听状态和多个连接状态的socket；
服务器需要处理多个网络协议的socket; 服务器需要同时处理不同的网络服务和协议。
聊天室所需要面对的情况正是第一和第三两种情况。我们将通过在TCP/IP协议之上建立一个功能简单的聊天室让大家更加了解多路I/O以及它的实现方法。
首先它是一个 client/server 结构的程序， 首先启动 server， 然后用户使用 client 进行连接。client/server 结构的优点是速度快， 缺点是当 server 进行更新时， client 也必需更新。

------------------------------------
努力学习xslt中...

[iintsy]

网络初始化
首先是初始化 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多路复用技术。多路复用一般有以下几种方法：

------------------------------------
努力学习xslt中...

[iintsy]

非阻塞通信方法：
将文件管道通过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。

[DeadWolf]

iintsy(Dandy) 你说的select ，
我看到的linux 网络编程中都用的这个。
windows中基本上也是用这个，
也就是调用select时候阻塞，如果返回再检查该做什么，如连接到达或者有数据可供读取。

windows下还有
WSAAsyncSelect ，WSAEventSelect
可以不阻塞，而通过窗口消息或者事件通知

[DeadWolf]

此外 普通的send 、recv这几个函数还是要花费一点点时间才能完成，特别是如果接受或发送的有点大的话，但是在windows下的 重叠模型 可以立即返回

[iintsy]

由于判断是否有新连接， 是否可读都是非阻塞的， 因此每次判断，不管有还是没有， 都会马上返回。 这样，任何一个 client 向 server 发送字符或者试图建立新连接， 都不会对其他 client 的活动造成影响。
对 client 而言， 建立连接之后， 只需要处理两个文件描述符， 一个是建立了连接的 socket 描述符， 另一个是标准输入和 server 一样， 如果使用阻塞方式的话， 很容易因为其中一个暂时没有输入而影响另外一个的读入。因此将它们都变成非阻塞的， 然后client 进行如下动作:
while ( 不想退出)
begin
if ( 与 server 的连接有字符可读)
begin
从该连接读入， 并输出到标准输出上去。
End;
if ( 标准输入可读)
Begin
从标准输入读入， 并输出到与 server 的连接中去。
End;
End。
上面的读写分别调用这样两个函数:
read( userfd[i]， line， MAX_LINE);
// userfd[i] 是指第 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% 左右都被其占用。极大的消耗了系统资源。
因此，虽然我们不希望在某一个用户没有反应时阻塞其他的用户，但我们却应该在没有任何用户有反应的情况之下停止程序的运行，让出抢占的系统资源，进入阻塞状态。有没有这种方法呢？现在的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[i]， sockset);
}
maxfd = 最大的文件描述符号 + 1;
server 处理如下:
while ( 1) {
select( maxfd， &sockset， NULL， NULL， NULL);
if ( FD_ISSET( sockfd， &sockset)) {
// 有新连接
建立新连接， 并将该连接描述符加入到 sockset 中去了。
}
for ( 所有有效连接) {
if ( FD_ISSET ( userfd[i]， &sockset)) {
// 该连接中有字符可读
从该连接中读入字符， 并发送到其他有效连接中去。
}
}
重新设置 sockset;
}
性能比较
由于采用 select 机制， 因此当没有字符可读时， 程序处于阻塞状态，最小程度的占用CPU 资源， 在同一台机器上执行一个 server 和若干个client 时， 系统负载只有 0。1 左右， 而采用原来的非阻塞通信方法， 只运行一个 server， 系统负载就可以达到 1。5 左右。 因此我们推荐使用 select。

------------------------------------
努力学习xslt中...

[iintsy]

二、程序说明
在具体实现过程中，服务器端采用的是线程阻塞的方式，即服务器端为每个客户端建立服务线程，采用阻塞的方式为每个客户服务。本思想来自Windows的Winsock编程。
服务器端关键代码如下：
int sockfd, cliensockfd[MAXSOCKFD];
struct sockaddr_in clientaddr[MAXSOCKFD];
/*
sockfd监听套接字
cliensockfd服务套接字组
clientaddr客户端的地址
*/
void ExchangeMsg(void* socketnum)
/*处理聊天信息，并发送到所有的客户端
[*socketnum]为该套接字在cliensockfd中的位置
*/
void CloseMainSock()
/* 关闭主套接字，并清除对它上面事件的申明。在程序结束前关闭主套接字是一个好习惯 */
void Func( void *ptr )
/*服务器端提示信息显示*/

主函数采用线程阻塞的方式：
while (1)
{
/*使用阻塞的方式等待连接*/
if ((newsockfd = accept(sockfd, (struct sockaddr*)&addr, &addr_len)) < 0)
{
perror("accept");
break;
}
/*查找一个未使用的套接字空间*/
for(i = 0; i < MAXSOCKFD;i++)
{
if(cliensockfd[i] == -1)
break;
}
if( i == MAXSOCKFD)
{
/*如果服务已满，关闭连接并给出提示*/
write(newsockfd,msgerror,sizeof(msgerror));
printf("too much client, connection refused!\n");
close(newsockfd);
}
else
{
/*保存当前连接的套接字及地址*/
cliensockfd[i] = newsockfd;
clientaddr[i].sin_family = addr.sin_family;
clientaddr[i].sin_port = addr.sin_port;
clientaddr[i].sin_addr.S_un = addr.sin_addr.S_un;
/*给出提示*/
memset(infobuffer,'\0',BUFFER);
sprintf(infobuffer,"客户 %d 轻轻的来了，带来一片欢声笑语...", i);
for(j = 0; j< MAXSOCKFD; j++)
{
if(cliensockfd[j] != -1 && i != j)
write(cliensockfd[j], infobuffer, strlen(infobuffer));
if( i == j)
write(newsockfd, msg, sizeof(msg));
}

printf("Connect from %s and socket_num = %d\n", inet_ntoa(addr.sin_addr),newsockfd);
/*为该套接字创建服务线程*/
if(pthread_create( &thread2[i], NULL,(void*)&ExchangeMsg, (void*)&i ))
{
fprintf(stderr,"Could not create thread %s",strerror(errno));
}
}
}
客户端使用的是select的方式，使用 select 判断一组文件描述符中是否有一个可读(写)， 如果没有就阻塞， 直到有一个的时候就被唤醒。select 方法中， 所有文件描述符都是阻塞的。
客户器端关键代码如下：
while( 1 )
{
readfds = readfds1;
/*select阻塞方式，判断一组文件描述符中是否有一个可读，但此处阻塞时间为0*/
if ((ret = select(sClient+1, &readfds, NULL,NULL,
&TimeOut)) < 0 )
{
printf("exit with error\n");
return(0);
}
if( ret == 0)
{
//printf("timeout\n");
;
}
/*判断文件描述符sClient是否有可读*/
if(FD_ISSET(sClient, &readfds))
{
bzero(szBuf, BUFFER);
if ((len = recv(sClient, szBuf, BUFFER, 0)) <=0 )
{
printf("server %d Connection closed.\n", sClient);
close(sClient);
exit(1);
}
else
{
printf("%s\n",szBuf);
if( strcmp(szBuf,msgerror) == 0)
{
perror(msgerror);
break;

}
}
}
/*判断标准输入是否有可读*/
if(FD_ISSET(0, &readfds))
{
memset(szMesg,'\0',BUFFER);
/*从标准数输入中读取*/
read(0, szMesg, BUFFER);
szMesg[strlen(szMesg)-1] = '\0';
if(strcmp(szMesg,"x" ) == 0 || strcmp(szMesg, "X") == 0 )
break;
if(strcmp(szMesg,"h" ) == 0 || strcmp(szMesg, "H") == 0 )
{
HelpMsg();
continue;
}
/*发送消息*/
if(ret = send( sClient, szMesg, strlen(szMesg), 0 )< 0)
{
perror("sending on stream socket !");
break;
}
printf("message send\n");
}
}

三、 程序运行结果
程序见附件中的server.c和client.c。
1、编译
编译命令如下：
服务器端：
gcc server.c -o server -lsocket -lnsl -lpthread
客户端：
gcc client.c -o client -lsocket -lnsl
编译成功后，即可运行。
2、运行
运行服务器：
server
客户端运行：
client

------------------------------------
努力学习xslt中...

[iintsy]

我这有两个自己写的学习用的程序，你需要的话可以发给你，留下你的e-mail
------------------------------------
努力学习xslt中...

[DeadWolf]

谢谢 代码我就不要了
我只是想知道linux除了使用select 模式进行socket编程
还有没有其他方式
特别是对性能有影响的方式

[DeadWolf]

普通的send 、recv这几个函数还是要花费一点点时间才能完成
对于规模不大的应用，这点时间可能没关系，但是如果程序客户规模很大，如一个web服务器，需要同事处理很多连接，那么这一点点时间乘上一个n[n=一个相对较大的数的时候]，性能影响就会体现出来了，所以我想有没有立即返回的方式

[DeadWolf]

自己顶一次

[oldbiestar]

poll和select在某些系统上面是等价的（仅仅是接口不一样，实现代码根本就是一个东西）

立即返回的是非阻塞式socket，这个和select配合起来才能真正起作用，对于阻塞式socket，select可以说是没有意义的。

send、和recv属于慢速调用，没有数据的时候会死等……

[sevencat]

linux有poll,epoll

[DeadWolf]

立即返回的是非阻塞式socket是不是就是windows下面说的异步sock

[skfox]

mark一下

[LDD123]

对于阻塞式socket，select可以说是没有意义的。
--------------------------------------------
这好像不对吧。
对于select管理多个socket时，不管这些socket是否阻塞还是不阻塞的，
select都是为了知道有读或写的事件发生，然后再决定要对那个socket读或写，
这至少比轮讯每个socket有效率多了。
linux下除了select还有epoll，听说比select的效率高许多。

[xiao_xiao_zi]

epoll不错
学习中

[wjlsmail]

Study

[normalnotebook]

你看看那本经典书籍 unix网络编程 上面就谈到了i/o模型。

好像有5种I/O模型吧。
大概有这几种方法：
select/poll/epoll/AIO/SIGIO
如果是BSD类型的UNIX，还有Kqueue

[DeadWolf]

谢谢了 结贴
学习的路还很长啊