多线程 线程池 sock IO复用
来源：互联网 发布：淘宝购物车的东西少了 编辑：程序博客网 时间：2024/06/05 18:13
1)iocp编程小结
http://www.cnblogs.com/Hybird3D/archive/2012/02/02/2335000.html
http://www.cnblogs.com/Hybird3D/archive/2012/02/04/2337652.html
单个进程最大线程数
转自：http://jackyhongvip.iteye.com/blog/1339768
原文链接：http://jzhihui.iteye.com/blog/1271122
windows 操作系统中允许的最大线程数。
===========================================================================
默认情况下，一个线程的栈要预留1M的内存空间
而一个进程中可用的内存空间只有2G，所以理论上一个进程中最多可以开2048个线程
但是内存当然不可能完全拿来作线程的栈，所以实际数目要比这个值要小。
你也可以通过连接时修改默认栈大小，将其改的比较小，这样就可以多开一些线程。
如将默认栈的大小改成512K，这样理论上最多就可以开4096个线程。
即使物理内存再大，一个进程中可以起的线程总要受到2GB这个内存空间的限制。
比方说你的机器装了64GB物理内存，但每个进程的内存空间还是4GB，其中用户态可用的还是2GB。
如果是同一台机器内的话，能起多少线程也是受内存限制的。每个线程对象都要站用非页面内存，而
非页面内存也是有限的，当非页面内存被耗尽时，也就无法创建线程了。
如果物理内存非常大，同一台机器内可以跑的线程数目的限制值会越来越大。
在Windows下写个程序，一个进程Fork出2000个左右线程就会异常退出了，为什么？
这个问题的产生是因为windows32位系统，一个进程所能使用的最大虚拟内存为2G，而一个线程的
默认线程栈StackSize为1024K（1M），这样当线程数量逼近2000时，2000*1024K=2G（大约），
内存资源就相当于耗尽。
MSDN原文：
“The number of threads a process can create is limited by the available virtual memory.
By default， every thread has one megabyte of stack space. Therefore， you can create
at most 2，028 threads. If you reduce the default stack size， you can create more threads. However， your application will have better performance if you create one thread per
processor and build queues of requests for which the application maintains the context
information. A thread would process all requests in a queue before processing requests
in the next queue.”
如何突破2000个限制？
可以通过修改CreateThread参数来缩小线程栈StackSize，例如
- #define MAX_THREADS 50000
- DWORD WINAPI ThreadProc（ LPVOID lpParam ）{
- while（1）{
- Sleep（100000）;
- }
- return 0;
- }
- int main（） {
- DWORD dwThreadId［MAX_THREADS］;
- HANDLE hThread［MAX_THREADS］;
- for（int i = 0; i < MAX_THREADS; ++i）{
- hThread［i］ = CreateThread（0， 64， ThreadProc， 0， STACK_SIZE_PARAM_IS_A_RESERVATION， &dwThreadId［i］）;
- if（0 == hThread［i］）{
- DWORD e = GetLastError（）;
- printf（“%d\r\n”，e）;
- break;
- }
- }
- ThreadProc（0）;
- }
- #define MAX_THREADS 50000
- DWORD WINAPI ThreadProc（ LPVOID lpParam ）{
- while（1）{
- Sleep（100000）;
- }
- return 0;
- }
- int main（） {
- DWORD dwThreadId［MAX_THREADS］;
- HANDLE hThread［MAX_THREADS］;
- for（int i = 0; i < MAX_THREADS; ++i）{
- hThread［i］ = CreateThread（0， 64， ThreadProc， 0， STACK_SIZE_PARAM_IS_A_RESERVATION， &dwThreadId［i］）;
- if（0 == hThread［i］）{
- DWORD e = GetLastError（）;
- printf（“%d\r\n”，e）;
- break;
- }
- }
- ThreadProc（0）;
- }
服务器端程序设计
如果你的服务器端程序设计成：来一个client连接请求则创建一个线程，那么就会存在2000个限制（在
硬件内存和CPU个数一定的情况下）。建议如下：
The “one thread per client” model is well-known not to scale beyond a dozen clients
or so. If you‘re going to be handling more than that many clients simultaneously，
you should move to a model where instead of dedicating a thread to a client， you
instead allocate an object. （Someday I’ll muse on the duality between threads and
objects.） Windows provides I/O completion ports and a thread pool to help you
convert from a thread-based model to a work-item-based model.
1. Serve many clients with each thread， and use nonblocking I/O and level-triggered
readiness notification
2. Serve many clients with each thread， and use nonblocking I/O and readiness
change notification
3. Serve many clients with each server thread， and use asynchronous I/O
--------------------
附：Win32将低区的2GB留给进程使用， 高区的2GB则留给系统使用。
Linux将高位1GB留给内核，低位3GB留给进程
linux系统中允许的最大线程数
==========================================================================================
JVM中可生成的最大Thread数量
JVM中可以生成的最大数量由JVM的堆内存大小、Thread的Stack内存大小、系统最大
可创建的线程数量（Java线程的实现是基于底层系统的线程机制来实现的，Windows下_beginthreadex，Linux下pthread_create）三个方面影响。
-Xms
intial java heap size
-Xmx
maximum java heap size
-Xss
the stack size for each thread
系统限制
系统最大可开线程数
测试程序如下：- import java.util.concurrent.atomic.AtomicInteger;
- public class TestThread extends Thread {
- private static final AtomicInteger count = new AtomicInteger();
- public static void main(String[] args) {
- while (true)
- (new TestThread()).start();
- }
- @Override
- public void run() {
- System.out.println(count.incrementAndGet());
- while (true)
- try {
- Thread.sleep(Integer.MAX_VALUE);
- } catch (InterruptedException e) {
- break;
- }
- }
- }
- import java.util.concurrent.atomic.AtomicInteger;
- public class TestThread extends Thread {
- private static final AtomicInteger count = new AtomicInteger();
- public static void main(String[] args) {
- while (true)
- (new TestThread()).start();
- }
- @Override
- public void run() {
- System.out.println(count.incrementAndGet());
- while (true)
- try {
- Thread.sleep(Integer.MAX_VALUE);
- } catch (InterruptedException e) {
- break;
- }
- }
- }
测试环境：
系统：Ubuntu 10.04 Linux Kernel 2.6 （32位）
内存：2G
JDK：1.7
测试结果：
◆ 不考虑系统限制
-Xms
-Xmx
-Xss
结果
1024m
1024m
1024k
1737
1024m
1024m
64k
26077
512m
512m
64k
31842
256m
256m
64k
31842
在创建的线程数量达到31842个时，系统中无法创建任何线程。
由上面的测试结果可以看出增大堆内存（-Xms，-Xmx）会减少可创建的线程数量，增大线程栈内存
（-Xss，32位系统中此参数值最小为60K）也会减少可创建的线程数量。
◆ 结合系统限制
线程数量31842的限制是是由系统可以生成的最大线程数量决定的：/proc/sys/kernel/threads-max，
可其默认值是32080。修改其值为10000：echo 10000 > /proc/sys/kernel/threads-max，
修改后的测试结果如下：
-Xms
-Xmx
-Xss
结果
256m
256m
64k
9761
这样的话，是不是意味着可以配置尽量多的线程？再做修改：echo 1000000 > /proc/sys/kernel/threads-max，
修改后的测试结果如下：
-Xms
-Xmx
-Xss
结果
256m
256m
64k
32279
128m
128m
64k
32279
发现线程数量在达到32279以后，不再增长。查了一下，32位Linux系统可创建的最大pid数是32678，
这个数值可以通过/proc/sys/kernel/pid_max来做修改（修改方法同threads-max），但是在32系
统下这个值只能改小，无法更大。在threads-max一定的情况下，修改pid_max对应的测试结果如下：
pid_max
-Xms
-Xmx
-Xss
结果
1000
128m
128m
64k
582
10000
128m
128m
64k
9507
在Windows上的情况应该类似，不过相比Linux，Windows上可创建的线程数量可能更少。基于线
总结：
JVM中可以生成的最大数量由JVM的堆内存大小、Thread的Stack内存大小、系统最大可创建的线程数量
（Java线程的实现是基于底层系统的线程机制来实现的，Windows下_beginthreadex，Linux下
pthread_create）三个方面影响。具体数量可以根据Java进程可以访问的最大内存（32位系统上一般2G）、
堆内存、Thread的Stack内存来估算。
序：
在64位Linux系统（CentOS 6， 3G内存）下测试，发现还有一个参数是会限制线程数量：
max user process（可通过ulimit –a查看，默认值1024，通过ulimit –u可以修改此值），
这个值在上面的32位Ubuntu测试环境下并无限制。
将threads-max，pid_max，max user process，这三个参数值都修改成100000，-Xms，
-Xmx尽量小（128m，64m），-Xss尽量小（64位下最小104k，可取值128k）。事先预测在
这样的测试环境下，线程数量就只会受限于测试环境的内存大小（3G），可是实际的测试结果是
线程数量在达到32K（32768，创建的数量最多的时候大概是33000左右）左右时JVM是抛出警告：
Attempt to allocate stack guard pages failed，然后出现OutOfMemoryError无法创建本
地线程。查看内存后发现还有很多空闲，所以应该不是内存容量的原因。Google此警告无果，
暂时不知什么原因，有待进一步研究。
序2：今天无意中发现文章[7]，马上试了下，果然这个因素会影响线程创建数量，按文中描述把/proc/sys/vm/max_map_count的数量翻倍，从65536变为131072，创建的线程总数
量达到65000+，电脑基本要卡死（3G内存）… 简单查了下这个参数的作用，在[8]中的描述如下：
“This file contains the maximum number of memory map areas a process may have.
Memory map areas are used as a side-effect of calling malloc, directly by mmap and
mprotect, and also when loading shared libraries.
While most applications need less than a thousand maps, certain programs,
particularly malloc debuggers, may consume lots of them, e.g., up to one or two
maps per allocation.
The default value is 65536.”
OK，这个问题总算完满解决，最后总结下影响Java线程数量的因素：
Java虚拟机本身：-Xms，-Xmx，-Xss；
系统限制：
/proc/sys/kernel/pid_max，
/proc/sys/kernel/thread-max，
max_user_process（ulimit -u），
/proc/sys/vm/max_map_count。
参考资料：
1. http://blog.krecan.net/2010/04/07/how-many-threads-a-jvm-can-handle/
2. http://www.cyberciti.biz/tips/maximum-number-of-processes-linux-26-kernel-can-handle.html
3. http://geekomatic.ch/2010/11/24/1290630420000.html
4. http://stackoverflow.com/questions/763579/how-many-threads-can-a-java-vm-support
5. http://www.iteye.com/topic/1035818
6. http://hi.baidu.com/hexiong/blog/item/16dc9e518fb10c2542a75b3c.html
7. https://listman.redhat.com/archives/phil-list/2003-August/msg00025.html
8. http://www.linuxinsight.com/proc_sys_vm_max_map_count.html
之前有看到用很幽默的方式讲解Windows的socket IO模型，
借用这个故事，讲解下linux的socket IO模型；
老陈有一个在外地工作的女儿，不能经常回来，老陈和她通过信件联系。
他们的信会被邮递员投递到他们小区门口的收发室里。这和Socket模型非常类似。
下面就以老陈接收信件为例讲解linux的 Socket I/O模型。
一、同步阻塞模型
老陈的女儿第一次去外地工作，送走她之后，老陈非常的挂心她安全到达没有；
于是老陈什么也不干，一直在小区门口收发室里等着她女儿的报平安的信到；
这就是linux的同步阻塞模式；
在这个模式中，用户空间的应用程序执行一个系统调用，并阻塞，
直到系统调用完成为止(数据传输完成或发生错误)。
Socket设置为阻塞模式，当socket不能立即完成I/O操作时，进程或线程进入等待状态，直到操作完成。
如图1所示：
/*
* \brief
* tcp client
*/
#include
#include
#include
#include
#include
#define SERVPORT 8080
#define MAXDATASIZE 100
int main(int argc, char *argv[])
{
int sockfd, recvbytes;
char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */
char snd_buf[MAXDATASIZE];
struct hostent *host; /* struct hostent
* {
* char *h_name; // general hostname
* char **h_aliases; // hostname's alias
* int h_addrtype; // AF_INET
* int h_length;
* char **h_addr_list;
* };
*/
struct sockaddr_in server_addr;
if (argc < 3)
{
printf("Usage:%s [ip address] [any string]\n", argv[0]);
return 1;
}
*snd_buf = '\0';
strcat(snd_buf, argv[2]);
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket:");
exit(1);
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVPORT);
inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
memset(&(server_addr.sin_zero), 0, 8);
/* create the connection by socket
* means that connect "sockfd" to "server_addr"
* 同步阻塞模式
*/
if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
{
perror("connect");
exit(1);
}
/* 同步阻塞模式 */
if (send(sockfd, snd_buf, sizeof(snd_buf), 0) == -1)
{
perror("send:");
exit(1);
}
printf("send:%s\n", snd_buf);
/* 同步阻塞模式 */
if ((recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, 0)) == -1)
{
perror("recv:");
exit(1);
}
rcv_buf[recvbytes] = '\0';
printf("recv:%s\n", rcv_buf);
close(sockfd);
return 0;
}
显然，代码中的connect, send, recv都是同步阻塞工作模式，
在结果没有返回时，程序什么也不做。
这种模型非常经典，也被广泛使用。
优势在于非常简单，等待的过程中占用的系统资源微乎其微，程序调用返回时，必定可以拿到数据；
但简单也带来一些缺点，程序在数据到来并准备好以前，不能进行其他操作，
需要有一个线程专门用于等待，这种代价对于需要处理大量连接的服务器而言，是很难接受的。
二、同步非阻塞模型
收到平安信后，老陈稍稍放心了，就不再一直在收发室前等信；
而是每隔一段时间就去收发室检查信箱；
这样，老陈也能在间隔时间内休息一会，或喝杯荼，看会电视，做点别的事情；
这就是同步非阻塞模型；
同步阻塞 I/O 的一种效率稍低的变种是同步非阻塞 I/O。
在这种模型中，系统调用是以非阻塞的形式打开的。
这意味着 I/O 操作不会立即完成， 操作可能会返回一个错误代码，
说明这个命令不能立即满足（EAGAIN 或 EWOULDBLOCK），
非阻塞的实现是 I/O 命令可能并不会立即满足，需要应用程序调用许多次来等待操作完成。
这可能效率不高，
因为在很多情况下，当内核执行这个命令时，应用程序必须要进行忙碌等待，直到数据可用为止，或者试图执行其他工作。
因为数据在内核中变为可用到用户调用 read 返回数据之间存在一定的间隔，这会导致整体数据吞吐量的降低。
如图2所示：
/*
* \brief
* tcp client
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define SERVPORT 8080
#define MAXDATASIZE 100
int main(int argc, char *argv[])
{
int sockfd, recvbytes;
char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */
char snd_buf[MAXDATASIZE];
struct hostent *host; /* struct hostent
* {
* char *h_name; // general hostname
* char **h_aliases; // hostname's alias
* int h_addrtype; // AF_INET
* int h_length;
* char **h_addr_list;
* };
*/
struct sockaddr_in server_addr;
int flags;
int addr_len;
if (argc < 3)
{
printf("Usage:%s [ip address] [any string]\n", argv[0]);
return 1;
}
*snd_buf = '\0';
strcat(snd_buf, argv[2]);
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket:");
exit(1);
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVPORT);
inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
memset(&(server_addr.sin_zero), 0, 8);
addr_len = sizeof(struct sockaddr_in);
/* Setting socket to nonblock */
flags = fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, flags|O_NONBLOCK);
/* create the connection by socket
* means that connect "sockfd" to "server_addr"
* 同步阻塞模式
*/
if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
{
perror("connect");
exit(1);
}
/* 同步非阻塞模式 */
while (send(sockfd, snd_buf, sizeof(snd_buf), MSG_DONTWAIT) == -1)
{
sleep(10);
printf("sleep\n");
}
printf("send:%s\n", snd_buf);
/* 同步非阻塞模式 */
while ((recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, MSG_DONTWAIT)) == -1)
{
sleep(10);
printf("sleep\n");
}
rcv_buf[recvbytes] = '\0';
printf("recv:%s\n", rcv_buf);
close(sockfd);
return 0;
}
这种模式在没有数据可以接收时，可以进行其他的一些操作，
比如有多个socket时，可以去查看其他socket有没有可以接收的数据；
实际应用中，这种I/O模型的直接使用并不常见，因为它需要不停的查询，
而这些查询大部分会是无必要的调用，白白浪费了系统资源；
非阻塞I/O应该算是一个铺垫，为I/O复用和信号驱动奠定了非阻塞使用的基础。
我们可以使用 fcntl(fd, F_SETFL, flag | O_NONBLOCK);
将套接字标志变成非阻塞，调用recv，
如果设备暂时没有数据可读就返回-1，同时置errno为EWOULDBLOCK（或者EAGAIN，这两个宏定义的值相同），
表示本来应该阻塞在这里（would block，虚拟语气），事实上并没有阻塞而是直接返回错误，调用者应该试着再读一次（again）。
这种行为方式称为轮询（Poll），调用者只是查询一下，而不是阻塞在这里死等，这样可以同时监视多个设备：
while(1)
{
非阻塞read(设备1);
if(设备1有数据到达)
处理数据;
非阻塞read(设备2);
if(设备2有数据到达)
处理数据;
..............................
}
如果read(设备1)是阻塞的，那么只要设备1没有数据到达就会一直阻塞在设备1的read调用上，
即使设备2有数据到达也不能处理，使用非阻塞I/O就可以避免设备2得不到及时处理。
非阻塞I/O有一个缺点，如果所有设备都一直没有数据到达，调用者需要反复查询做无用功，如果阻塞在那里，
操作系统可以调度别的进程执行，就不会做无用功了，在实际应用中非阻塞I/O模型比较少用
三、I/O复用(异步阻塞)模式
频繁地去收发室对老陈来说太累了，在间隔的时间内能做的事也很少，而且取到信的效率也很低.
于是，老陈向小区物业提了建议；
小区物业改进了他们的信箱系统：
住户先向小区物业注册，之后小区物业会在已注册的住户的家中添加一个提醒装置，
每当有注册住房的新的信件来临，此装置会发出 "新信件到达"声，
提醒老陈去看是不是自己的信到了。
这就是异步阻塞模型；
在这种模型中，配置的是非阻塞 I/O，然后使用阻塞 select 系统调用来确定一个 I/O 描述符何时有操作。
使 select 调用非常有趣的是它可以用来为多个描述符提供通知，而不仅仅为一个描述符提供通知。
对于每个提示符来说，我们可以请求这个描述符可以写数据、有读数据可用以及是否发生错误的通知
I/O复用模型能让一个或多个socket可读或可写准备好时，应用能被通知到；
I/O复用模型早期用select实现，它的工作流程如下图：
图3
用select来管理多个I/O，当没有数据时select阻塞，如果在超时时间内数据到来则select返回，
再调用recv进行数据的复制，recv返回后处理数据。
下面的C语言实现的例子，它从网络上接受数据写入一个文件中:
/*
* \brief
* tcp client
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define SERVPORT 8080
#define MAXDATASIZE 100
#define TFILE "data_from_socket.txt"
int main(int argc, char *argv[])
{
int sockfd, recvbytes;
char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */
char snd_buf[MAXDATASIZE];
struct hostent *host; /* struct hostent
* {
* char *h_name; // general hostname
* char **h_aliases; // hostname's alias
* int h_addrtype; // AF_INET
* int h_length;
* char **h_addr_list;
* };
*/
struct sockaddr_in server_addr;
/* */
fd_set readset, writeset;
int check_timeval = 1;
struct timeval timeout={check_timeval,0}; //阻塞式select, 等待1秒，1秒轮询
int maxfd;
int fp;
int cir_count = 0;
int ret;
if (argc < 3)
{
printf("Usage:%s [ip address] [any string]\n", argv[0]);
return 1;
}
*snd_buf = '\0';
strcat(snd_buf, argv[2]);
if ((fp = open(TFILE,O_WRONLY)) < 0) //不是用fopen
{
perror("fopen:");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket:");
exit(1);
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVPORT);
inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
memset(&(server_addr.sin_zero), 0, 8);
/* create the connection by socket
* means that connect "sockfd" to "server_addr"
*/
if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
{
perror("connect");
exit(1);
}
/**/
if (send(sockfd, snd_buf, sizeof(snd_buf), 0) == -1)
{
perror("send:");
exit(1);
}
printf("send:%s\n", snd_buf);
while (1)
{
FD_ZERO(&readset); //每次循环都要清空集合，否则不能检测描述符变化
FD_SET(sockfd, &readset); //添加描述符
FD_ZERO(&writeset);
FD_SET(fp, &writeset);
maxfd = sockfd > fp ? (sockfd+1) : (fp+1); //描述符最大值加1
ret = select(maxfd, &readset, NULL, NULL, NULL); // 阻塞模式
switch( ret)
{
case -1:
exit(-1);
break;
case 0:
break;
default:
if (FD_ISSET(sockfd, &readset)) //测试sock是否可读，即是否网络上有数据
{
recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, MSG_DONTWAIT);
rcv_buf[recvbytes] = '\0';
printf("recv:%s\n", rcv_buf);
if (FD_ISSET(fp, &writeset))
{
write(fp, rcv_buf, strlen(rcv_buf)); // 不是用fwrite
}
goto end;
}
}
cir_count++;
printf("CNT : %d \n",cir_count);
}
end:
close(fp);
close(sockfd);
return 0;
}
perl实现:
#! /usr/bin/perl
###############################################################################
# \File
# tcp_client.pl
# \Descript
# send message to server
###############################################################################
use IO::Socket;
use IO::Select;
#hash to install IP Port
%srv_info =(
#"srv_ip" => "61.184.93.197",
"srv_ip" => "192.168.1.73",
"srv_port"=> "8080",
);
my $srv_addr = $srv_info{"srv_ip"};
my $srv_port = $srv_info{"srv_port"};
my $sock = IO::Socket::INET->new(
PeerAddr => "$srv_addr",
PeerPort => "$srv_port",
Type => SOCK_STREAM,
Blocking => 1,
# Timeout => 5,
Proto => "tcp")
or die "Can not create socket connect. $@";
$sock->send("Hello server!\n", 0) or warn "send failed: $!, $@";
$sock->autoflush(1);
my $sel = IO::Select->new($sock);
while(my @ready = $sel->can_read)
{
foreach my $fh(@ready)
{
if($fh == $sock)
{
while()
{
print $_;
}
$sel->remove($fh);
close $fh;
}
}
}
$sock->close();
四、信号驱动I/O模型
老陈接收到新的信件后，一般的程序是：
打开信封----掏出信纸 ----阅读信件----回复信件 ......
为了进一步减轻用户负担，小区物业又开发了一种新的技术：
住户只要告诉小区物业对信件的操作步骤，小区物业信箱将按照这些步骤去处理信件，
不再需要用户亲自拆信 /阅读/回复了！
这就是信号驱动I/O模型
我们也可以用信号，让内核在描述字就绪时发送SIGIO信号通知我们。
首先开启套接口的信号驱动 I/O功能，并通过sigaction系统调用安装一个信号处理函数。
该系统调用将立即返回，我们的进程继续工作，也就是说没被阻塞。
当数据报准备好读取时，内核就为该进程产生一个SIGIO信号，
我们随后既可以在信号处理函数中调用recvfrom读取数据报，并通知主循环数据已准备好待处理，
也可以立即通知主循环，让它读取数据报。
无论如何处理SIGIO信号，这种模型的优势在于等待数据报到达期间，进程不被阻塞，主循环可以继续执行，
只要不时地等待来自信号处理函数的通知：既可以是数据已准备好被处理，也可以是数据报已准备好被读取。
五、异步非阻塞模式
linux下的asynchronous IO其实用得很少。
与前面的信号驱动模型的主要区别在于：信号驱动 I/O是由内核通知我们何时可以启动一个 I/O操作，
而异步 I/O模型是由内核通知我们 I/O操作何时完成 。
先看一下它的流程：
图5：
这就是异步非阻塞模式
以read系统调用为例
steps：
a. 调用read;
b. read请求会立即返回，说明请求已经成功发起了。
c. 在后台完成读操作这段时间内，应用程序可以执行其他处理操作。
d. 当 read 的响应到达时，就会产生一个信号或执行一个基于线程的回调函数来完成这次 I/O 处理过程。
/*
* \brief
* tcp client
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define SERVPORT 8080
#define MAXDATASIZE 100
#define TFILE "data_from_socket.txt"
int main(int argc, char *argv[])
{
int sockfd, recvbytes;
char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */
char snd_buf[MAXDATASIZE];
struct hostent *host; /* struct hostent
* {
* char *h_name; // general hostname
* char **h_aliases; // hostname's alias
* int h_addrtype; // AF_INET
* int h_length;
* char **h_addr_list;
* };
*/
struct sockaddr_in server_addr;
/* */
fd_set readset, writeset;
int check_timeval = 1;
struct timeval timeout={check_timeval,0}; //阻塞式select, 等待1秒，1秒轮询
int maxfd;
int fp;
int cir_count = 0;
int ret;
if (argc < 3)
{
printf("Usage:%s [ip address] [any string]\n", argv[0]);
return 1;
}
*snd_buf = '\0';
strcat(snd_buf, argv[2]);
if ((fp = open(TFILE,O_WRONLY)) < 0) //不是用fopen
{
perror("fopen:");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket:");
exit(1);
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVPORT);
inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
memset(&(server_addr.sin_zero), 0, 8);
/* create the connection by socket
* means that connect "sockfd" to "server_addr"
*/
if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
{
perror("connect");
exit(1);
}
/**/
if (send(sockfd, snd_buf, sizeof(snd_buf), 0) == -1)
{
perror("send:");
exit(1);
}
printf("send:%s\n", snd_buf);
while (1)
{
FD_ZERO(&readset); //每次循环都要清空集合，否则不能检测描述符变化
FD_SET(sockfd, &readset); //添加描述符
FD_ZERO(&writeset);
FD_SET(fp, &writeset);
maxfd = sockfd > fp ? (sockfd+1) : (fp+1); //描述符最大值加1
ret = select(maxfd, &readset, NULL, NULL, &timeout); // 非阻塞模式
switch( ret)
{
case -1:
exit(-1);
break;
case 0:
break;
default:
if (FD_ISSET(sockfd, &readset)) //测试sock是否可读，即是否网络上有数据
{
recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, MSG_DONTWAIT);
rcv_buf[recvbytes] = '\0';
printf("recv:%s\n", rcv_buf);
if (FD_ISSET(fp, &writeset))
{
write(fp, rcv_buf, strlen(rcv_buf)); // 不是用fwrite
}
goto end;
}
}
timeout.tv_sec = check_timeval; // 必须重新设置，因为超时时间到后会将其置零
cir_count++;
printf("CNT : %d \n",cir_count);
}
end:
close(fp);
close(sockfd);
return 0;
}
server端程序:
/*
* \brief
* tcp server
*/
#include
#include
#include
#include
#include
#include
#include
#define SERVPORT 8080
#define BACKLOG 10 // max numbef of client connection
#define MAXDATASIZE 100
int main(char argc, char *argv[])
{
int sockfd, client_fd, addr_size, recvbytes;
char rcv_buf[MAXDATASIZE], snd_buf[MAXDATASIZE];
char* val;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
int bReuseaddr = 1;
char IPdotdec[20];
/* create a new socket and regiter it to os .
* SOCK_STREAM means that supply tcp service,
* and must connect() before data transfort.
*/
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket:");
exit(1);
}
/* setting server's socket */
server_addr.sin_family = AF_INET; // IPv4 network protocol
server_addr.sin_port = htons(SERVPORT);
server_addr.sin_addr.s_addr = INADDR_ANY; // auto IP detect
memset(&(server_addr.sin_zero),0, 8);
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&bReuseaddr, sizeof(int));
if (bind(sockfd, (struct sockaddr*)&server_addr, sizeof(struct sockaddr))== -1)
{
perror("bind:");
exit(1);
}
/*
* watting for connection ,
* and server permit to recive the requestion from sockfd
*/
if (listen(sockfd, BACKLOG) == -1) // BACKLOG assign thd max number of connection
{
perror("listen:");
exit(1);
}
while(1)
{
addr_size = sizeof(struct sockaddr_in);
/*
* accept the sockfd's connection,
* return an new socket and assign far host to client_addr
*/
printf("watting for connect...\n");
if ((client_fd = accept(sockfd, (struct sockaddr *)&client_addr, &addr_size)) == -1)
{
/* Nonblocking mode */
perror("accept:");
continue;
}
/* network-digital to ip address */
inet_ntop(AF_INET, (void*)&client_addr, IPdotdec, 16);
printf("connetion from:%d : %s\n",client_addr.sin_addr, IPdotdec);
//if (!fork())
{
/* child process handle with the client connection */
/* recive the client's data by client_fd */
if ((recvbytes = recv(client_fd, rcv_buf, MAXDATASIZE, 0)) == -1)
{
perror("recv:");
exit(1);
}
rcv_buf[recvbytes]='\0';
printf("recv:%s\n", rcv_buf);
*snd_buf='\0';
strcat(snd_buf, "welcome");
sleep(3);
/* send the message to far-hosts by client_fd */
if (send(client_fd, snd_buf, strlen(snd_buf), 0) == -1)
{
perror("send:");
exit(1);
}
printf("send:%s\n", snd_buf);
close(client_fd);
//exit(1);
}
//close(client_fd);
}
return 0;
}
用户进程发起read操作之后，立刻就可以开始去做其它的事。
而另一方面，从kernel的角度，当它受到一个asynchronous read之后，首先它会立刻返回，
所以不会对用户进程产生任何block。
然后，kernel会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，
kernel会给用户进程发送一个signal，告诉它read操作完成了。
六、总结
到目前为止，已经将四个IO Model都介绍完了。
现在回过头来回答两个问题：
. blocking和non-blocking的区别在哪?
. synchronous IO和asynchronous IO的区别在哪。
先回答最简单的这个：blocking vs non-blocking。
前面的介绍中其实已经很明确的说明了这两者的区别。
. 调用blocking IO会一直block住对应的进程直到操作完成，
. 而non-blocking IO在kernel还在准备数据的情况下会立刻返回。
在说明synchronous IO和asynchronous IO的区别之前，需要先给出两者的定义。
Stevens给出的定义（其实是POSIX的定义）是这样子的：
. A synchronous I/O operation causes the requesting process to be blocked until that I/O operation completes;
. An asynchronous I/O operation does not cause the requesting process to be blocked;
两者的区别就在于:
synchronous IO做”IO operation”的时候会将process阻塞。
按照这个定义，之前所述的blocking IO，non-blocking IO，IO multiplexing都属于synchronous IO。
有人可能会说，non-blocking IO并没有被block啊。这里有个非常“狡猾”的地方，
定义中所指的”IO operation”是指真实的IO操作，就是例子中的recvfrom这个system call。
. non-blocking IO在执行recvfrom这个system call的时候，如果kernel的数据没有准备好，这时候不会block进程。
但是，当kernel中数据准备好的时候，recvfrom会将数据从kernel拷贝到用户内存中，
这个时候进程是被block了，在这段时间内，进程是被block的。
. 而asynchronous IO则不一样，当进程发起IO 操作之后，就直接返回再也不理睬了，
直到kernel发送一个信号，告诉进程说IO完成。在这整个过程中，进程完全没有被block。
各个IO Model的比较如图所示：
图6
经过上面的介绍，会发现non-blocking IO和asynchronous IO的区别还是很明显的:
. 在non-blocking IO中，虽然进程大部分时间都不会被block，但是它仍然要求进程去主动的check，
并且当数据准备完成以后，也需要进程主动的再次调用recvfrom来将数据拷贝到用户内存。
. 而asynchronous IO则完全不同。它就像是用户进程将整个IO操作交给了他人（kernel）完成，
然后他人做完后发信号通知。在此期间，用户进程不需要去检查IO操作的状态，也不需要主动的去拷贝数据。
最后，再举几个不是很恰当的例子来说明这五个IO Model:
有A，B，C，D，E五个人钓鱼：
. A用的是最老式的鱼竿，所以呢，得一直守着，等到鱼上钩了再拉杆；
. B的鱼竿有个功能，能够显示是否有鱼上钩，所以呢，B就和旁边的MM聊天，
隔会再看看有没有鱼上钩，有的话就迅速拉杆；
. C用的鱼竿和B差不多，但他想了一个好办法，就是同时放好几根鱼竿，然后守在旁边，
一旦有显示说鱼上钩了，它就将对应的鱼竿拉起来；
. D是个有钱人，他没耐心等， 但是又喜欢钓上鱼的快感，所以雇了个人，一旦那个人发现有鱼上钩，
就会通知D过来把鱼钓上来；
. E也是个有钱人，干脆雇了一个人帮他钓鱼，一旦那个人把鱼钓上来了，就给E发个短信。
1、为什么select落后
首先，在Linux内核中，select所用到的FD_SET是有限的，即内核中有个参数__FD_SETSIZE定义了每个FD_SET的句柄个数，在 我用的2.6.15-25-386内核中，该值是1024，搜索内核源代码得到：
include/linux/posix_types.h:
#define __FD_SETSIZE 1024
也就是说，如果想要同时检测1025个句柄的可读状态是不可能用select实现的。或者 同时检测1025个句柄的可写状态也是不可能的。其次，内核中实现 select是用轮询方法，即每次检测都会遍历所有FD_SET中的句柄，显然，select函数执行时间与FD_SET中的句柄个数有一个比例关系，即 select要检测的句柄数越多就会越费时。当然，在前文中我并没有提及poll方法，事实上用select的朋友一定也试过poll，我个人觉得 select和poll大同小异，个人偏好于用select而已。
2、内核中提高I/O性能的新方法epoll
epoll是什么？按照man手册的说法：是为处理大批量句柄而作了改进的poll。要使用epoll只需要这三个系统调 用：epoll_create(2)， epoll_ctl(2)， epoll_wait(2)。
当然，这不是2.6内核才有的，它是在 2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44)
Linux2.6 内核epoll介绍
先介绍2本书《The Linux Networking Architecture--Design and Implementation of Network Protocols in the Linux Kernel》，以2.4内核讲解Linux TCP/IP实现，相当不错.作为一个现实世界中的实现，很多时候你必须作很多权衡，这时候参考一个久经考验的系统更有实际意义。举个例子,linux内 核中sk_buff结构为了追求速度和安全，牺牲了部分内存，所以在发送TCP包的时候，无论应用层数据多大,sk_buff最小也有272的字节.其实 对于socket应用层程序来说，另外一本书《UNIX Network Programming Volume 1》意义更大一点.2003年的时候，这本书出了最新的第3版本，不过主要还是修订第2版本。其中第6章《I/O Multiplexing》是最重要的。Stevens给出了网络IO的基本模型。在这里最重要的莫过于select模型和Asynchronous I/O模型.从理论上说，AIO似乎是最高效的，你的IO操作可以立即返回，然后等待os告诉你IO操作完成。但是一直以来，如何实现就没有一个完美的方 案。最著名的windows完成端口实现的AIO,实际上也是内部用线程池实现的罢了，最后的结果是IO有个线程池，你应用也需要一个线程池...... 很多文档其实已经指出了这带来的线程context-switch带来的代价。在linux 平台上，关于网络AIO一直是改动最多的地方，2.4的年代就有很多AIO内核patch,最著名的应该算是SGI那个。但是一直到2.6内核发布，网络 模块的AIO一直没有进入稳定内核版本(大部分都是使用用户线程模拟方法，在使用了NPTL的linux上面其实和windows的完成端口基本上差不多 了)。2.6内核所支持的AIO特指磁盘的AIO---支持io_submit(),io_getevents()以及对Direct IO的支持(就是绕过VFS系统buffer直接写硬盘，对于流服务器在内存平稳性上有相当帮助)。
所以，剩下的select模型基本上就是我们在linux上面的唯一选择，其实，如果加上no-block socket的配置，可以完成一个"伪"AIO的实现，只不过推动力在于你而不是os而已。不过传统的select/poll函数有着一些无法忍受的缺 点，所以改进一直是2.4-2.5开发版本内核的任务，包括/dev/poll，realtime signal等等。最终，Davide Libenzi开发的epoll进入2.6内核成为正式的解决方案
3、epoll的优点
<1>支持一个进程打开大数 目的socket描述符(FD)
select 最不能忍受的是一个进程所打开的FD是有一定限制的，由FD_SETSIZE设置，默认值是2048。对于那些需要支持的上万连接数目的IM服务器来说显 然太少了。这时候你一是可以选择修改这个宏然后重新编译内核，不过资料也同时指出这样会带来网络效率的下降，二是可以选择多进程的解决方案(传统的 Apache方案)，不过虽然linux上面创建进程的代价比较小，但仍旧是不可忽视的，加上进程间数据同步远比不上线程间同步的高效，所以也不是一种完 美的方案。不过 epoll则没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左 右，具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。
<2>IO 效率不随FD数目增加而线性下降
传统的select/poll另一个致命弱点就是当你拥有一个很大的socket集合，不过由于网络延时，任一时间只有部分的socket是"活跃"的， 但是select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是epoll不存在这个问题，它只会对"活跃"的socket进行 操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。那么，只有"活跃"的socket才会主动的去调用 callback函数，其他idle状态socket则不会，在这点上，epoll实现了一个"伪"AIO，因为这时候推动力在os内核。在一些 benchmark中，如果所有的socket基本上都是活跃的---比如一个高速LAN环境，epoll并不比select/poll有什么效率，相 反，如果过多使用epoll_ctl,效率相比还有稍微的下降。但是一旦使用idle connections模拟WAN环境,epoll的效率就远在select/poll之上了。
<3>使用mmap加速内核 与用户空间的消息传递。
这点实际上涉及到epoll的具体实现了。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就 很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。而如果你想我一样从2.5内核就关注epoll的话，一定不会忘记手工 mmap这一步的。
<4>内核微调
这一点其实不算epoll的优点了，而是整个linux平台的优点。也许你可以怀疑 linux平台，但是你无法回避linux平台赋予你微调内核的能力。比如，内核TCP/IP协议栈使用内存池管理sk_buff结构，那么可以在运行时 期动态调整这个内存pool(skb_head_pool)的大小--- 通过echo XXXX>/proc/sys/net/core/hot_list_length完成。再比如listen函数的第2个参数(TCP完成3次握手 的数据包队列长度)，也可以根据你平台内存大小动态调整。更甚至在一个数据包面数目巨大但同时每个数据包本身大小却很小的特殊系统上尝试最新的NAPI网 卡驱动架构。
4、epoll的工作模式
令人高兴的是，2.6内核的epoll比其2.5开发版本的/dev/epoll简洁了许多，所以，大部分情况下，强大的东西往往是简单的。唯一有点麻烦 是epoll有2种工作方式:LT和ET。
LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你 的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表．
ET (edge-triggered)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述 符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致 了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(on
epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用，具体用法请参考http://www.xmailserver.org/linux-patches/nio-improve.html ，在http://www.kegel.com/rn/也有一个完整的例子，大家一看就知道如何使用了
Leader/follower模式线程 pool实现，以及和epoll的配合。
5、 epoll的使用方法
首先通过create_epoll(int maxfds)来创建一个epoll的句柄，其中maxfds为你epoll所支持的最大句柄数。这个函数会返回一个新的epoll句柄，之后的所有操作 将通过这个句柄来进行操作。在用完之后，记得用close()来关闭这个创建出来的epoll句柄。之后在你的网络主循环里面，每一帧的调用 epoll_wait(int epfd, epoll_event events, int max events, int timeout)来查询所有的网络接口，看哪一个可以读，哪一个可以写了。基本的语法为：
nfds = epoll_wait(kdpfd, events, maxevents, -1);
其中kdpfd为用epoll_create创建之后的句柄，events是一个 epoll_event*的指针，当epoll_wait这个函数操作成功之后，epoll_events里面将储存所有的读写事件。 max_events是当前需要监听的所有socket句柄数。最后一个timeout是 epoll_wait的超时，为0的时候表示马上返回，为-1的时候表示一直等下去，直到有事件范围，为任意正整数的时候表示等这么长的时间，如果一直没 有事件，则范围。一般如果网络主循环是单独的线程的话，可以用-1来等，这样可以保证一些效率，如果是和主逻辑在同一个线程的话，则可以用0来保证主循环 的效率。
Epoll模型主要负责对大量并发用户的请求进行及时处理，完成服务器与客户端的数据交互。其具体的实现步骤如下：
(a) 使用epoll_create()函数创建文件描述，设定将可管理的最大socket描述符数目。
(b) 创建与epoll关联的接收线程，应用程序可以创建多个接收线程来处理epoll上的读通知事件，线程的数量依赖于程序的具体需要。
(c) 创建一个侦听socket描述符ListenSock；将该描述符设定为非阻塞模式，调用Listen（）函数在套接字上侦听有无新的连接请求，在 epoll_event结构中设置要处理的事件类型EPOLLIN，工作方式为 epoll_ET，以提高工作效率，同时使用epoll_ctl()注册事件，最后启动网络监视线程。
(d) 网络监视线程启动循环，epoll_wait()等待epoll事件发生。
(e) 如果epoll事件表明有新的连接请求，则调用accept（）函数，将用户socket描述符添加到epoll_da
(f) 如果epoll事件表明socket描述符上有数据可读，则将该socket描述符加入可读队列，通知接收线程读入数据，并将接收到的数据放入到接收数据 的链表中，经逻辑处理后，将反馈的数据包放入到发送数据链表中，等待由发送线程发送。
02 for (n = 0; n < nfds;++n)
03 {
04 if (events[n].da
05 {//如果是主socket的事件的话，则表示有新连接进入了，进行新连接的处理。
06 client = accept (listener, (structsockaddr*)&local,&addrlen);
07 if (client < 0)
08 {
09 perror ("accept");
10 continue;
11 }
12 setnonblocking (client); // 将新连接置于非阻塞模式
13 ev.events=EPOLLIN |EPOLLET;// 并且将新连接也加入EPOLL的监听队列。
14 //注意，这里的参数EPOLLIN | EPOLLET并没有设置对写socket的监听，
15 //如果有写操作的话，这个时候epoll是不会返回事件的，
16 //如果要对写操作也监听的话，应该是EPOLLIN | EPOLLOUT | EPOLLET
17 ev.da
18 if (epoll_ctl (kdpfd,EPOLL_CTL_ADD,client,&ev)<0)
19 {
20 /*
21 设置好event之后，将这个新的event通过epoll_ctl加入到epoll的监听队列里面，
22 这里用EPOLL_CTL_ADD来加一个新的epoll事件,通过EPOLL_CTL_DEL来减少一个epoll事件，通
23 过EPOLL_CTL_MOD来改变一个事件的监听方式.
24 */
25 fprintf (stderr,"epoll set insertion error: fd=%d",client);
26 return -1;
27 }
28 }
29 else // 如果不是主socket的事件的话，则代表是一个用户socket的事件，
30 do_use_fd (events[n].da
31 }
对，epoll的操作就这么简单，总共不过4个 API：epoll_create, epoll_ctl, epoll_wait和close。
如果您对epoll的效率还不太了解，请参考我 之前关于网络游戏的网络编程等相关的文章。
以前公司的服务器都是使用HTTP连接，但是这样的话，在手机目前的网络情况下不但显得速度较慢，而且不稳定。因此大家一致同意用 SOCKET来进行连接。虽然使用SOCKET之后，对于用户的费用可能会增加(由于是用了CMNET而非CMWAP)，但是，秉着用户体验至上的原则， 相信大家还是能够接受的(希望那些玩家月末收到帐单不后能够保持克制...)。
这次的服务器设计中，最重要的一个突破，是使用了EPOLL模型， 虽然对之也是一知半解，但是既然在各大PC网游中已经经过了如此严酷的考验，相信他不会让我们失望，使用后的结果，确实也是表现相当不错。在这里，我还是 主要大致介绍一下这个模型的结构。
6、Linux下EPOll编程实例
EPOLL模型似乎只有一种格式，所以大家只要参考我下面的代码， 就能够对EPOLL有所了解了，代码的解释都已经在注释中：
02 {
03 int nfds =epoll_wait (m_epoll_fd,m_events,MAX_EVENTS,EPOLL_TIME_OUT); //等待EPOLL时间的发生，相当于监听，
04 //至于相关的端口，需要在初始化EPOLL的时候绑定。
05 if (nfds <=0)
06 continue;
07 m_bOnTimeChecking=FALSE;
08 G_CurTime=time (NULL);
09 for (int i = 0; i <nfds;i++)
10 {
11 try
12 {
13 if (m_events[i].da
14 //建立新的连接。由于我们新采用了SOCKET连接，所以基本没用。
15 {
16 On
17 }
18 else if (m_events[i].da
19 //建立新的连接。
20 {
21 On
22 }
23 else if (m_events[i].events&EPOLLIN)//如果是已经连接的用户，并且收到数据，那么进行读入。
24 {
25 On
26 }
27
28 On
29 }
30 catch (int)
31 {
32 PRINTF ("CATCH捕获错误\n");
33 continue;
34 }
35 }
36 m_bOnTimeChecking=TRUE;
37 On
38 }
3)select、poll、epoll之间的区别总结[整理]
转自：http://www.cnblogs.com/Anker/p/3265058.html
select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。关于这三种IO多路复用的用法，前面三篇总结写的很清楚，并用服务器回射echo程序进行了测试。连接如下所示：
select：http://www.cnblogs.com/Anker/archive/2013/08/14/3258674.html
poll：http://www.cnblogs.com/Anker/archive/2013/08/15/3261006.html
epoll：http://www.cnblogs.com/Anker/archive/2013/08/17/3263780.html
今天对这三种IO多路复用进行对比，参考网上和书上面的资料，整理如下：
1、select实现
select的调用过程如下所示：
（1）使用copy_from_user从用户空间拷贝fd_set到内核空间
（2）注册回调函数__pollwait
（3）遍历所有fd，调用其对应的poll方法（对于socket，这个poll方法是sock_poll，sock_poll根据情况会调用到tcp_poll,udp_poll或者datagram_poll）
（4）以tcp_poll为例，其核心实现就是__pollwait，也就是上面注册的回调函数。
（5）__pollwait的主要工作就是把current（当前进程）挂到设备的等待队列中，不同的设备有不同的等待队列，对于tcp_poll来说，其等待队列是sk->sk_sleep（注意把进程挂到等待队列中并不代表进程已经睡眠了）。在设备收到一条消息（网络设备）或填写完文件数据（磁盘设备）后，会唤醒设备等待队列上睡眠的进程，这时current便被唤醒了。
（6）poll方法返回时会返回一个描述读写操作是否就绪的mask掩码，根据这个mask掩码给fd_set赋值。
（7）如果遍历完所有的fd，还没有返回一个可读写的mask掩码，则会调用schedule_timeout是调用select的进程（也就是current）进入睡眠。当设备驱动发生自身资源可读写后，会唤醒其等待队列上睡眠的进程。如果超过一定的超时时间（schedule_timeout指定），还是没人唤醒，则调用select的进程会重新被唤醒获得CPU，进而重新遍历fd，判断有没有就绪的fd。
（8）把fd_set从内核空间拷贝到用户空间。
总结：
select的几大缺点：
（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大
（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大
（3）select支持的文件描述符数量太小了，默认是1024
2 poll实现
poll的实现和select非常相似，只是描述fd集合的方式不同，poll使用pollfd结构而不是select的fd_set结构，其他的都差不多。
关于select和poll的实现分析，可以参考下面几篇博文：
http://blog.csdn.net/lizhiguo0532/article/details/6568964#comments
http://blog.csdn.net/lizhiguo0532/article/details/6568968
http://blog.csdn.net/lizhiguo0532/article/details/6568969
http://www.ibm.com/developerworks/cn/linux/l-cn-edntwk/index.html?ca=drs-
http://linux.chinaunix.net/techdoc/net/2009/05/03/1109887.shtml
3、epoll
epoll既然是对select和poll的改进，就应该能避免上述的三个缺点。那epoll都是怎么解决的呢？在此之前，我们先看一下epoll和select和poll的调用接口上的不同，select和poll都只提供了一个函数——select或者poll函数。而epoll提供了三个函数，epoll_create,epoll_ctl和epoll_wait，epoll_create是创建一个epoll句柄；epoll_ctl是注册要监听的事件类型；epoll_wait则是等待事件的产生。
对于第一个缺点，epoll的解决方案在epoll_ctl函数中。每次注册新的事件到epoll句柄中时（在epoll_ctl中指定EPOLL_CTL_ADD），会把所有的fd拷贝进内核，而不是在epoll_wait的时候重复拷贝。epoll保证了每个fd在整个过程中只会拷贝一次。
对于第二个缺点，epoll的解决方案不像select或poll一样每次都把current轮流加入fd对应的设备等待队列中，而只在epoll_ctl时把current挂一遍（这一遍必不可少）并为每个fd指定一个回调函数，当设备就绪，唤醒等待队列上的等待者时，就会调用这个回调函数，而这个回调函数会把就绪的fd加入一个就绪链表）。epoll_wait的工作实际上就是在这个就绪链表中查看有没有就绪的fd（利用schedule_timeout()实现睡一会，判断一会的效果，和select实现中的第7步是类似的）。
对于第三个缺点，epoll没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左右，具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。
总结：
（1）select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。而epoll其实也需要调用epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在“醒着”的时候要遍历整个fd集合，而epoll在“醒着”的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间。这就是回调机制带来的性能提升。
（2）select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，并且要把current往设备等待队列中挂一次，而epoll只要一次拷贝，而且把current往等待队列上挂也只挂一次（在epoll_wait的开始，注意这里的等待队列并不是设备等待队列，只是一个epoll内部定义的等待队列）。这也能节省不少的开销。
参考资料：
http://www.cnblogs.com/apprentice89/archive/2013/05/09/3070051.html
http://www.linuxidc.com/Linux/2012-05/59873p3.htm
http://xingyunbaijunwei.blog.163.com/blog/static/76538067201241685556302/
http://blog.csdn.net/kkxgx/article/details/7717125
https://banu.com/blog/2/how-to-use-epoll-a-complete-example-in-c/epoll-example.c
4)socket编程之select()
Select在Socket编程中还是比较重要的，它能够监视我们需要监视的文件描述符的变化情况——读写或是异常。
Select的函数格式(Unix系统下的伯克利socket编程，和windows下的略有区别，体现两个方面：一是select函数的第一个参数，在windows下可以忽略，但在linux下必须设为最大文件描述符加1；二是结构fd_set在两个系统里定义不一样)：
int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval *timeout); /*参数列表int maxfdp是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错！在Windows中这个参数的值无所谓，可以设置不正确。 fd_set *readfds是指向fd_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的读变化的，即我们关心是否可以从这些文件中读取数据了，如果这个集合中有一个文件可读，select就会返回一个大于0的值，表示有文件可读，如果没有可读的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的读变化。 fd_set *writefds是指向fd_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的写变化的，即我们关心是否可以向这些文件中写入数据了，如果这个集合中有一个文件可写，select就会返回一个大于0的值，表示有文件可写，如果没有可写的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的写变化。 fd_set *errorfds同上面两个参数的意图，用来监视文件错误异常。 struct timeval* timeout是select的超时时间，这个参数至关重要，它可以使select处于三种状态：第一，若将NULL以形参传入，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止；第二，若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值；第三，timeout的值大于0，这就是等待的超时时间，即 select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。*/
/*返回值：
负值：select错误正值：某些文件可读写或出错0：等待超时，没有可读写或错误的文件*/说明两个结构体：
第一，struct fd_set可以理解为一个集合，这个集合中存放的是文件描述符(file descriptor)，即文件句柄，这可以是我们所说的普通意义的文件，当然Unix下任何设备、管道、FIFO等都是文件形式，全部包括在内，所以毫无疑问一个socket就是一个文件，socket句柄就是一个文件描述符。fd_set集合可以通过一些宏由人为来操作，比如清空集合 FD_ZERO(fd_set *)，将一个给定的文件描述符加入集合之中FD_SET(int ,fd_set *)，将一个给定的文件描述符从集合中删除FD_CLR(int ,fd_set*)，检查集合中指定的文件描述符是否可以读写FD_ISSET(int ,fd_set* )。一会儿举例说明。
第二，struct timeval是一个大家常用的结构，用来代表时间值，有两个成员，一个是秒数，另一个是毫秒数。
在有了select后可以写出像样的网络程序来！举个简单的例子，就是从网络上接受数据写入一个文件中。
#include <winsock.h> #include <stdio.h> #define PORT 5150 #define MSGSIZE 1024 #pragma comment(lib, "ws2_32.lib") int g_iTotalConn = 0; SOCKET g_CliSocketArr[FD_SETSIZE]; DWORD WINAPI WorkerThread(LPVOID lpParameter); int main() { WSADATA wsaData; SOCKET sListen, sClient; SOCKADDR_IN local, client; int iaddrSize = sizeof(SOCKADDR_IN); DWORD dwThreadId; // Initialize Windows socket library WSAStartup(0x0202, &wsaData); // Create listening socket sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Bind local.sin_addr.S_un.S_addr = htonl(INADDR_ANY); local.sin_family = AF_INET; local.sin_port = htons(PORT); bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN)); // Listen listen(sListen, 3); // Create worker thread CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId); while (TRUE) { // Accept a connection sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize); printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port)); // Add socket to g_CliSocketArr g_CliSocketArr[g_iTotalConn++] = sClient; } return 0; } DWORD WINAPI WorkerThread(LPVOID lpParam) { int i; fd_set fdread; int ret; struct timeval tv = {1, 0}; char szMessage[MSGSIZE]; while (TRUE) { FD_ZERO(&fdread); for (i = 0; i < g_iTotalConn; i++) { FD_SET(g_CliSocketArr, &fdread); } // We only care read event ret = select(0, &fdread, NULL, NULL, &tv); if (ret == 0) { // Time expired continue; } for (i = 0; i < g_iTotalConn; i++) { if (FD_ISSET(g_CliSocketArr, &fdread)) { // A read event happened on g_CliSocketArr ret = recv(g_CliSocketArr, szMessage, MSGSIZE, 0); if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET)) { // Client socket closed printf("Client socket %d closed.\n", g_CliSocketArr); closesocket(g_CliSocketArr); if (i < g_iTotalConn - 1) { g_CliSocketArr[i--] = g_CliSocketArr[--g_iTotalConn]; } } else { // We received a message from client szMessage[ret] = '\0'; send(g_CliSocketArr, szMessage, strlen(szMessage), 0); } } //if }//for }//while return 0; }
服务器的几个主要动作如下：
1.创建监听套接字，绑定，监听；
2.创建工作者线程；
3.创建一个套接字数组，用来存放当前所有活动的客户端套接字，每accept一个连接就更新一次数组；
4.接受客户端的连接。
这里有一点需要注意的，就是我没有重新定义FD_SETSIZE宏，所以服务器最多支持的并发连接数为64。而且，这里决不能无条件的accept,服务器应该根据当前的连接数来决定是否接受来自某个客户端的连接。一种比较好的实现方案就是采用WSAAccept函数，而且让WSAAccept回调自己实现的Condition Function。
如下所示：
int CALLBACK ConditionFunc(LPWSABUF lpCallerId,LPWSABUF lpCallerData, LPQOS lpSQOS,LPQOS lpGQOS,LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,GROUP FAR * g,DWORD dwCallbackData) { if (当前连接数 < FD_SETSIZE) return CF_ACCEPT; else return CF_REJECT; }
工作者线程里面是一个死循环，一次循环完成的动作是：
1.将当前所有的客户端套接字加入到读集fdread中；
2.调用select函数；
3.查看某个套接字是否仍然处于读集中，如果是，则接收数据。如果接收的数据长度为0，或者发生WSAECONNRESET错误，则表示客户端套接字主动关闭，这时需要将服务器中对应的套接字所绑定的资源释放掉，然后调整我们的套接字数组（将数组中最后一个套接字挪到当前的位置上）。
除了需要有条件接受客户端的连接外，还需要在连接数为0的情形下做特殊处理，因为如果读集中没有任何套接字，select函数会立刻返回，这将导致工作者线程成为一个毫无停顿的死循环，CPU的占用率马上达到100%。
关系到套接字列表的操作都需要使用循环,在轮询的时候,需要遍历一次,再新的一轮开始时,将列表加入队列又需要遍历一次.也就是说,Select在工作一次时,需要至少遍历2次列表,这是它效率较低的原因之一.
在大规模的网络连接方面,还是推荐使用IOCP或EPOLL模型.但是Select模型可以使用在诸如对战类游戏上,比如类似星际这种,因为它小巧易于实现,且对战类游戏的网络连接量并不大. 对于Select模型想要突破Windows 64个限制的话,可以采取分段轮询,一次轮询64个.例如套接字列表为128个,在第一次轮询时,将前64个放入队列中用Select进行状态查询, 待本次操作全部结束后.将后64个再加入轮询队列中进行轮询处理.这样处理需要在非阻塞式下工作.以此类推,Select也能支持无限多个。
- 多线程 线程池 sock IO复用
- 多线程 线程池 sock IO复用
- 文件IO，多线程，线程同步
- Angular + Electron + Sock.io 实战
- 线程、多线程、线程池
- 线程、多线程、线程池
- 线程、多线程、线程池
- “多线程IO”和“单线程异步IO”的对比
- “多线程IO”和“单线程异步IO”的对比
- “多线程IO”和“单线程异步IO”的对比【转】
- “多线程IO”和“单线程异步IO”的对比
- 线程、多线程与线程池
- 线程、多线程、线程池总结
- 13.高级IO和多线程和线程同步
- 【线程】线程/多线程问题/线程池
- 多线程-线程池
- 【多线程】线程池
- c# 线程池 多线程
- 【OSS】文件夹相关操作
- 组合数
- 一个好看的样式，datagriview
- 怎样在自定义工具中添加箭头工具
- C++<algorithm>中sort的比较函数写法
- 多线程 线程池 sock IO复用
- G++ 输出高亮
- Android照片墙完整版，完美结合LruCache和DiskLruCache
- php实现web端批量杀死Linux进程和清理内存
- java反射详解
- 百度地图无法定位，即无法调用onReceiveLocation。
- 模糊查询
- Linux中搭建SVN服务器
- C++ 堆排序算法
