网络编程select
① java的selector网络编程：怎样给特定channel发信息
如果不需要考虑网络安全之类的话，全频公放好了，将前几个字节设为客户端代号，消息到达各客户端的时候，客户端自己对照自己的代号，如果是，则对消息进行相关处理，如果不是，略过，等待下一条信息的接收
一个人对一个人的：消息带着代号传到服务器，服务器全频广播，只有要发送的对象发现是给自己的，处理，其他人略过
一个人对所有人：消息不带代号，即前几个字节设为特定数值，服务器全频广播，各客户端发现是所有人的，开始处理
这样一来就非常好实现了，不涉及复杂结构
② c++网络编程中，究竟什么是异步IO 还有那个select函数是异步IO
基本一样，JAVA现在用的多，大型开发环境
③ IO模型及select，poll，epoll和kqueue的区别
（一）首先，介绍几种常见的I/O模型及其区别，如下：
blocking I/O
nonblocking I/O
I/O multiplexing (select and poll)
signal driven I/O (SIGIO)
asynchronous I/O (the POSIX aio_functions)—————异步IO模型最大的特点是 完成后发回通知。
阻塞与否，取决于实现IO交换的方式。
异步阻塞是基于select，select函数本身的实现方式是阻塞的，而采用select函数有个好处就是它可以同时监听多个文件句柄.
异步非阻塞直接在完成后通知，用户进程只需要发起一个IO操作然后立即返回，等IO操作真正的完成以后，应用程序会得到IO操作完成的通知，此时用户进程只需要对数据进行处理就好了，不需要进行实际的IO读写操作，因为真正的IO读取或者写入操作已经由内核完成了。
1 blocking I/O
这个不用多解释吧，阻塞套接字。下图是它调用过程的图示：
重点解释下上图，下面例子都会讲到。首先application调用 recvfrom()转入kernel，注意kernel有2个过程，wait for data和 data from kernel to user。直到最后 complete后，recvfrom()才返回。此过程一直是阻塞的。
2 nonblocking I/O：
与blocking I/O对立的，非阻塞套接字，调用过程图如下：
可以看见，如果直接操作它，那就是个轮询。。直到内核缓冲区有数据。
3 I/O multiplexing (select and poll)
最常见的I/O复用模型，select。
select先阻塞，有活动套接字才返回。与blocking I/O相比，select会有两次系统调用，但是select能处理多个套接字。
4 signal driven I/O (SIGIO)
只有UNIX系统支持，感兴趣的课查阅相关资料
与I/O multiplexing (select and poll)相比，它的优势是，免去了select的阻塞与轮询，当有活跃套接字时，由注册的handler处理。
5 asynchronous I/O (the POSIX aio_functions)
很少有*nix系统支持，windows的IOCP则是此模型
完全异步的I/O复用机制，因为纵观上面其它四种模型，至少都会在由kernel data to appliction时阻塞。而该模型是当完成后才通知application，可见是纯异步的。好像只有windows的完成端口是这个模型，效率也很出色。
6 下面是以上五种模型的比较
可以看出，越往后，阻塞越少，理论上效率也是最优。
=====================分割线==================================
5种模型的比较比较清晰了，剩下的就是把select,epoll,iocp,kqueue按号入座那就OK了。
select和iocp分别对应第3种与第5种模型，那么epoll与kqueue呢？其实也于select属于同一种模型，只是更高级一些，可以看作有了第4种模型的某些特性，如callback机制。
为什么epoll,kqueue比select高级？
答案是，他们无轮询。因为他们用callback取代了。想想看，当套接字比较多的时候，每次select()都要通过遍历FD_SETSIZE个Socket来完成调度,不管哪个Socket是活跃的,都遍历一遍。这会浪费很多CPU时间。如果能给套接字注册某个回调函数，当他们活跃时，自动完成相关操作，那就避免了轮询，这正是epoll与kqueue做的。
windows or *nix （IOCP or kqueue/epoll）？
诚然，Windows的IOCP非常出色，目前很少有支持asynchronous I/O的系统，但是由于其系统本身的局限性，大型服务器还是在UNIX下。而且正如上面所述，kqueue/epoll 与 IOCP相比，就是多了一层从内核数据到应用层的阻塞，从而不能算作asynchronous I/O类。但是，这层小小的阻塞无足轻重，kqueue与epoll已经做得很优秀了。
提供一致的接口，IO Design Patterns
实际上，不管是哪种模型，都可以抽象一层出来，提供一致的接口，广为人知的有ACE,Libevent（基于reactor模式）这些，他们都是跨平台的，而且他们自动选择最优的I/O复用机制，用户只需调用接口即可。说到这里又得说说2个设计模式，Reactor and Proactor。见：Reactor模式--VS--Proactor模式。Libevent是Reactor模型，ACE提供Proactor模型。实际都是对各种I/O复用机制的封装。
Java nio包是什么I/O机制？
现在可以确定，目前的java本质是select()模型，可以检查/jre/bin/nio.dll得知。至于java服务器为什么效率还不错。。我也不得而知，可能是设计得比较好吧。。-_-。
=====================分割线==================================
总结一些重点：
只有IOCP是asynchronous I/O，其他机制或多或少都会有一点阻塞。
select低效是因为每次它都需要轮询。但低效也是相对的，视情况而定，也可通过良好的设计改善
epoll, kqueue、select是Reacor模式，IOCP是Proactor模式。
java nio包是select模型。。
（二）epoll 与select的区别
1. 使用多进程或者多线程，但是这种方法会造成程序的复杂，而且对与进程与线程的创建维护也需要很多的开销。（Apache服务器是用的子进程的方式，优点可以隔离用户） （同步阻塞IO）
2.一种较好的方式为I/O多路转接（I/O multiplexing）（貌似也翻译多路复用），先构造一张有关描述符的列表（epoll中为队列），然后调用一个函数，直到这些描述符中的一个准备好时才返回，返回时告诉进程哪些I/O就绪。select和epoll这两个机制都是多路I/O机制的解决方案，select为POSIX标准中的，而epoll为linux所特有的。
区别（epoll相对select优点）主要有三：
1.select的句柄数目受限，在linux/posix_types.h头文件有这样的声明：#define __FD_SETSIZE 1024 表示select最多同时监听1024个fd。而epoll没有，它的限制是最大的打开文件句柄数目。
2.epoll的最大好处是不会随着FD的数目增长而降低效率，在selec中采用轮询处理，其中的数据结构类似一个数组的数据结构，而epoll是维护一个队列，直接看队列是不是空就可以了。epoll只会对"活跃"的socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。那么，只有"活跃"的socket才会主动的去调用 callback函数（把这个句柄加入队列），其他idle状态句柄则不会，在这点上，epoll实现了一个"伪"AIO。但是如果绝大部分的I/O都是“活跃的”，每个I/O端口使用率很高的话，epoll效率不一定比select高（可能是要维护队列复杂）。
3.使用mmap加速内核与用户空间的消息传递。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。
关于epoll工作模式ET，LT
epoll有两种工作方式
ET：Edge Triggered，边缘触发。仅当状态发生变化时才会通知，epoll_wait返回。换句话，就是对于一个事件，只通知一次。且只支持非阻塞的socket。
LT：Level Triggered，电平触发（默认工作方式）。类似select/poll,只要还有没有处理的事件就会一直通知，以LT方式调用epoll接口的时候，它就相当于一个速度比较快的poll.支持阻塞和不阻塞的socket。
三 Linux并发网络编程模型
1 Apache 模型，简称 PPC （ Process Per Connection ，）:为每个连接分配一个进程。主机分配给每个连接的时间和空间上代价较大，并且随着连接的增多，大量进程间切换开销也增长了。很难应对大量的客户并发连接。
2 TPC 模型（ Thread Per Connection ）：每个连接一个线程。和PCC类似。
3 select 模型：I/O多路复用技术。
.1 每个连接对应一个描述。select模型受限于 FD_SETSIZE即进程最大打开的描述符数linux2.6.35为1024,实际上linux每个进程所能打开描数字的个数仅受限于内存大小，然而在设计select的系统调用时，却是参考FD_SETSIZE的值。可通过重新编译内核更改此值，但不能根治此问题，对于百万级的用户连接请求 即便增加相应 进程数， 仍显得杯水车薪呀。
.2select每次都会扫描一个文件描述符的集合，这个集合的大小是作为select第一个参数传入的值。但是每个进程所能打开文件描述符若是增加了 ，扫描的效率也将减小。
.3内核到用户空间，采用内存复制传递文件描述上发生的信息。
4 poll 模型：I/O多路复用技术。poll模型将不会受限于FD_SETSIZE，因为内核所扫描的文件 描述符集合的大小是由用户指定的，即poll的第二个参数。但仍有扫描效率和内存拷贝问题。
5 pselect模型：I/O多路复用技术。同select。
6 epoll模型：
.1)无文件描述字大小限制仅与内存大小相关
.2)epoll返回时已经明确的知道哪个socket fd发生了什么事件，不用像select那样再一个个比对。
.3)内核到用户空间采用共享内存方式，传递消息。
四 ：FAQ
1、单个epoll并不能解决所有问题，特别是你的每个操作都比较费时的时候，因为epoll是串行处理的。 所以你有还是必要建立线程池来发挥更大的效能。
2、如果fd被注册到两个epoll中时，如果有时间发生则两个epoll都会触发事件。
3、如果注册到epoll中的fd被关闭，则其会自动被清除出epoll监听列表。
4、如果多个事件同时触发epoll，则多个事件会被联合在一起返回。
5、epoll_wait会一直监听epollhup事件发生，所以其不需要添加到events中。
6、为了避免大数据量io时，et模式下只处理一个fd,其他fd被饿死的情况发生。linux建议可以在fd联系到的结构中增加ready位，然后epoll_wait触发事件之后仅将其置位为ready模式，然后在下边轮询ready fd列表。
④ c++网络编程中~~~究竟什么是异步IO 还有那个select函数是异步IO
异步文件IO也就是重叠IO。
在同步文件IO中，线程启动一个IO操作然后就立即进入等待状态，直到IO操作完成后才醒来继续执行。而异步文件IO方式中，线程发送一个IO请求到内核，然后继续处理其他的事情，内核完成IO请求后，将会通知线程IO操作完成了。
如果IO请求需要大量时间执行的话，异步文件IO方式可以显着提高效率，因为在线程等待的这段时间内，CPU将会调度其他线程进行执行，如果没有其他线程需要执行的话，这段时间将会浪费掉（可能会调度操作系统的零页线程）。如果IO请求操作很快，用异步IO方式反而还低效，还不如用同步IO方式。
同步IO在同一时刻只允许一个IO操作，也就是说对于同一个文件句柄的IO操作是序列化的，即使使用两个线程也不能同时对同一个文件句柄同时发出读写操作。重叠IO允许一个或多个线程同时发出IO请求。
异步IO在请求完成时，通过将文件句柄设为有信号状态来通知应用程序，或者应用程序通过GetOverlappedResult察看IO请求是否完成，也可以通过一个事件对象来通知应用程序。
例如DeviceIoControl这个函数，他就可以通过参数指定是同步或异步，如果是同步的话，则该函数将会等待结果返回后，才执行下一条语句。如果是异步的话，DeviceIoControl调用后马上返回，如果参数正确，则回返回ERROR_IO_PENDING（忘了怎样写，不过肯定是有PENDING这个词），然后你可以通过GetOverlappedResult获取返回结果，是一个overlap结构，是在你调用DeviceIoControl的最后一个参数传进去的``
简单的说``同步在编程里，一般是指某个操作执行完后，才可以执行后面的操作``拿到IO上来说``就是我要做完这个IO操作``才继续后面的操作```
异步则是，我交带了某个操作给系统（可以是windows，也可以是你自己的库），我呆会过来拿，我现在要去忙别的``拿到IO上说``我交带了某个IO操作给系统。。。。。
⑤ 如何使用windows网络编程select
1. select系统调用
select系统调用是用来让我们的程序监视多个文件描述符的状态变化的。程序会停在select这里等待，直到被监视的文件描述符有某一个或多个发生了状态改变。
select()的机制中提供一fd_set的数据结构，实际上是一long类型的数组，每一个数组元素都能与一打开的文件句柄建立联系，建立联系的工作由程序员完成，当调用select()时，由内核根据IO状态修改fd_set的内容，由此来通知执行了select()的进程哪些Socket或文件可读可写。
select函数原型：
#include <sys/select.h> #include <sys/time.h>#include <sys/types.h>#include <unistd.h>int select(int nfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, const struct timeval * timeout);
ndfs：select监视的文件句柄数，视进程中打开的文件数而定，一般设为要监视各文件中的最大文件描述符值加1。
readfds：这个文件描述符集合监视文件集中的任何文件是否有数据可读，当select函数返回的时候，readfds将清除其中不可读的文件描述符，只留下可读的文件描述符。
writefds：这个文件描述符集合监视文件集中的任何文件是否有数据可写，当select函数返回的时候，writefds将清除其中不可写的文件描述符，只留下可写的文件描述符。
exceptfds：这个文件集将监视文件集中的任何文件是否发生错误，其实，它可用于其他的用途，例如，监视带外数据OOB，带外数据使用MSG_OOB标志发送到套接字上。当select函数返回的时候，exceptfds将清除其中的其他文件描述符，只留下标记有OOB数据的文件描述符。
timeout：本次select()的超时结束时间。这个参数至关重要，它可以使select处于三种状态：
（1）若将NULL以形参传入，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止；
（2）若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值；
（3）timeout的值大于0，这就是等待的超时时间，即select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。
函数的返回值：
正值：表示监视的文件集中有文件描述符符合要求
零值：表示select监视超时
负值：表示发生了错误，错误值由errno指定。
宏操作：
FD_ZERO(fd_set *set)： 用来清除描述词组set的全部位
FD_SET(int fd,fd_set*set)： 用来设置描述词组set中相关fd的位
FD_ISSET(int fd,fd_set *set)： 用来测试描述词组set中相关fd 的位是否为真
FD_CLR(inr fd,fd_set* set)： 用来清除描述词组set中相关fd 的位注意事项：
（1）对于可写性的检查，最好放在需要写数据的时候进行检查。如果和可读性放在同一个地方进行检查，那么select很可能每次都会因为可写性检查成功而返回。
（2）select()调用会清空传递给它的集合参数中的内容，也就是会清空readfds、writefd、exceptfds这三个指针参数所指定的描述符集合。因此，在每次调用select()之前,必须重新初始化并把需要监视的描述符填写到相应的描述符集合中。select()调用也会清空timeout指针所指向的struct timeval结构，所以在每次调用select()之前也要重新填充timeout指针所指向的struct timeval结构。
⑥ 网络编程中，select模型是否要重置fet_set状态
select是需要重置set的：
intselect(intmaxfdp1,fd_set*readfds,
fd_set*writefds,fd_set*exceptfds,
structtimeval*tvptr);
可以参阅《Advanced Programming in the UNIX Environment》，或者具体平台的manual。
通俗的说readfds, writefds, exceptfds即做“输入参数”，也做“输出参数”，就是传进去后会对应的fd_set被修改。
比如APUE上写到：
There are three possible return values from select.
1. A return value of −1 means that an error occurred. This can happen, for
example, if a signal is caught before any of the specified descriptors are ready.
In this case, none of the descriptor sets will be modified.
2. A return value of 0 means that no descriptors are ready. This happens if the
time limit expires before any of the descriptors are ready. When this happens,
all the descriptor sets will be zeroed out.
3. A positive return value specifies the number of descriptors that are ready. This
value is the sum of the descriptors ready in all three sets, so if the same
descriptor is ready to be read and written, it will be counted twice in the return
value. The only bits left on in the three descriptor sets are the bits
corresponding to the descriptors that are ready.
其中2.的最后一句就提到：如果select只是因为timeout到了，所有（readfds, writefds, exceptfds）都会被置为空。
⑦ Python网络编程中替代select模块的方法有哪些
、导入模块
import mole
from mole.xx import xx
from mole.xx import xx as rename
from mole.xx import *
二、源模块
yum、pip、apt-get
源码编译安装：Python setup.py build Python setup install
三、用模块
os模块#用作系统级别工作
sys模块#提供解释器相关操作
hashlib模块# 用于加密相关操作
jsonpickle模块 #用于序列化数据
subprocess模块
shuit模块 #文件复制移
logging模块#格式化记录志
random模块 用于取随机数
time datetime模块间模块
re模块 则匹配
⑧ java网络编程写一个基础的小程序一直提示 java.net.SocketException: select failed
据上面显示的是：连接失败
可能是连接语句出错了，好好检查一下细节方面
例如：
服务器端需要指定一个确定的端口号来创建创建服务器对象
Socket socket = new Socket("168.150.12.53",9999);
并用此端口号进行监听。。
Socket s = server.accept() ; // 监听窗口,等待连接
或：
Socket socket = new Socket(InetAddress.getLocalHost(),5678); // 向主机名为InetAddress.getLocalHost()的服务器申请连接
客户端需用服务器所在机器的ip以及服务器的端口作为参数创建一个Socket对象
Socket socket = new Socket("168.160.12.42",9998);
或：
Socket socket = new Socket(InetAddress.getLocalHost(),5678); // 向主机名为InetAddress.getLocalHost()的服务器申请连接
⑨ linux网络编程，可以用select函数代替accept函数接收客户端的connect请求吗
select不可以替代accept，但可以用来作辅助，比如
nfds = select(Fd + 1, &fds, NULL, NULL , &tv);
if(nfds>0){
if (listenSock != -1 && FD_ISSET(listenSock, &fds))
{
if ((sock = accept(listenSock,(struct sockaddr *)&addr, &addrlen)) < 0)
{
return -1;
}
}
}
大概就这样
⑩ 网络编程中select函数如何接受一个accept事件
#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);
//这里client的SOCKADDR_IN client 中可以取出IP
printf("Accepted client:%s:%d ", 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};//超时时间 SELECT模型中用到的这里是1秒
char szMessage[MSGSIZE];//信息数组，事实上就是个缓冲区
while (TRUE)
{
FD_ZERO(&fdread);//清空fd_set结构
for (i = 0; i < g_iTotalConn; i++)
{
FD_SET(g_CliSocketArr[i], &fdread);//把客户套接字放到SELECT要求的数组中
}
//**************************************
// We only care read event
//只关心读的情况
ret = select(0, &fdread, NULL, NULL, &tv);
if (ret == 0)
{
// Time expired 超时
continue;
}
//如果SELECT返回不是0
for (i = 0; i < g_iTotalConn; i++)
{
if (FD_ISSET(g_CliSocketArr[i], &fdread))
{
// A read event happened on g_CliSocketArr[i]
//一个可读发生在这个套接字上
ret = recv(g_CliSocketArr[i], szMessage, MSGSIZE, 0);
//把它读出到缓冲区
if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
{
// Client socket closed
//客户端关闭
printf("Client socket %d closed. ", g_CliSocketArr[i]);
closesocket(g_CliSocketArr[i]);//关闭这个套接字
if (i < g_iTotalConn - 1)
{
//将数组中最后一个套接字挪到当前的位置上
g_CliSocketArr[i--] = g_CliSocketArr[--g_iTotalConn];
}
}
else
{
// We received a message from client
//如果以上没发生，那么就接收到一个客户端的信息
szMessage[ret] = ' ';
//直接回送回去
send(g_CliSocketArr[i], szMessage, strlen(szMessage), 0);
}
}
}
}
return 0;
}