python select模块_python select模块

一、前言

Python的select()方法直接调用操作系统的IO接口，它监控sockets,open files, and pipes(所有带fileno()方法的文件句柄)何时变成readable 和writeable, 或者通信错误，select()使得同时监控多个连接变的简单，并且这比写一个长循环来等待和监控多客户端连接要高效，因为select直接通过操作系统提供的C的网络接口进行操作，而不是通过Python的解释器。

注意：Using Python’s file objects with select() works for Unix, but is not supported under Windows.

二、select socket

接下来通过socket server例子要以了解select 是如何通过单进程实现同时处理多个非阻塞的socket连接的

2.1 socket server 开始监听

2.2 3个通信列表

select()方法接收并监控3个通信列表， 第一个是所有的输入的data,就是指外部发过来的数据，第2个是监控和接收所有要发出去的data(outgoing data),第3个监控错误信息，接下来我们需要创建2个列表来包含输入和输出信息来传给select()。

2.3 添加一个队列

所有客户端的进来的连接和数据将会被server的主循环程序放在上面的list中处理，我们现在的server端需要等待连接可写(writable)之后才能过来，然后接收数据并返回(因此不是在接收到数据之后就立刻返回)，因为每个连接要把输入或输出的数据先缓存到queue里，然后再由select取出来再发出去。

Connections are added to and removed from these lists by the server main loop. Since this version of the server is going to wait for a socket to become writable before sending any data (instead of immediately sending the reply), each output connection needs a queue to act as a buffer for the data to be sent through it.

2.4 主循环

当你把inputs,outputs,exceptional(这里跟inputs共用)传给

2.5 Readable list

Readable list 中的socket 可以有3种可能状态，第一种是如果这个socket是main "server" socket,它负责监听客户端的连接，如果这个main server socket出现在readable里，那代表这是server端已经ready来接收一个新的连接进来了，为了让这个main server能同时处理多个连接，在下面的代码里，我们把这个main server的socket设置为非阻塞模式。

第二种情况是这个socket是已经建立了的连接，它把数据发了过来，这个时候你就可以通过recv()来接收它发过来的数据，然后把接收到的数据放到queue里，这样你就可以把接收到的数据再传回给客户端了。

第三种情况就是这个客户端已经断开了，所以你再通过recv()接收到的数据就为空了，所以这个时候你就可以把这个跟客户端的连接关闭了。

2.6 writable list

对于writable list中的socket，也有几种状态，如果这个客户端连接在跟它对应的queue里有数据，就把这个数据取出来再发回给这个客户端，否则就把这个连接从output list中移除，这样下一次循环select()调用时检测到outputs list中没有这个连接，那就会认为这个连接还处于非活动状态

2.7 exceptional condition

最后，如果在跟某个socket连接通信过程中出了错误，就把这个连接对象在inputs\outputs\message_queue中都删除，再把连接关闭掉

注： getpeername() / getsocketname

getpeername可以获得服务器的地址信息和端口号，正好和getsockname获得本机地址信息和端口号完全相反

三、完整事例

select server

client

要理解select.select模块其实主要就是要理解它的参数, 以及其三个返回值。

select()方法接收并监控3个通信列表， 第一个是所有的输入的data,就是指外部发过来的数据，第2个是监控和接收所有要发出去的data(outgoing data),第3个监控错误信息

在网上一直在找这个select.select的参数解释, 但实在是没有, 哎...自己硬着头皮分析了一下。

readable, writable, exceptional = select.select(inputs, outputs, inputs)

select 函数的参数其实很好理解, 前提是我们对unix 网络编程有了解. select 模型是unix 系统中的网络模型, python 将其封装了,因此我们使用起来就比较方便, 但是面试官就不会这么觉得了(最近被面试逼疯了, 考虑问题都从面试官的角度考虑), 先说下unix 系统中的select 模型吧, 参数原型:

int select(int maxfdpl, fd_set * readset, fd_set *writeset, fd_set *exceptset, const struct timeval * tiomeout)

第一个是最大的文件描述符长度

第二个是监听的可读集合

第三个是监听的可写集合

第四个是监听的异常集合

第五个是时间限制

对struct fd_set结构体操作的宏

FD_SETSIZE 容量，指定fd_array数组大小，默认为64，也可自己修改宏

FD_ZERO(*set) 置空，使数组的元素值都为3435973836，元素个数为0.

FD_SET(s, *set) 添加，向 struct fd_set结构体添加套接字s

FD_ISSET(s, *set) 判断，判断s是否为 struct fd_set结构体中的一员

FD_CLR(s, *set) 删除，从 struct fd_set结构体中删除成员s

因为此模型主要是在网络中应用, 我们不考虑文件, 设备, 单从套接字来考虑, 可读条件如下:

可写条件如下:

我看C 示例的时候, 看的有点懵逼, 应该需要跑一遍代码就好, python 就简单了, 直接调用封装好的select , 其底层处理好了文件描述符的相关读写监听(回头再研究下), 我们在Python 中只需这么写:

can_read, can_write, _ = select.select(inputs, outputs, None, None)

第一个参数是我们需要监听可读的套接字, 第二个参数是我们需要监听可写的套接字, 第三个参数使我们需要监听异常的套接字, 第四个则是时间限制设置.

如果监听的套接字满足了可读可写条件, 那么所返回的can,read 或是 can_write就会有值了, 然后我们就可以利用这些返回值进行随后的操作了。相比较unix 的select模型, 其select函数的返回值是一个整型, 用以判断是否执行成功.

第一个参数就是服务器端的socket, 第二个是我们在运行过程中存储的客户端的socket, 第三个存储错误信息。

重点是在返回值, 第一个返回的是可读的list, 第二个存储的是可写的list, 第三个存储的是错误信息的

list。

网上所有关于select.select的代码都是差不多的, 但是有些不能运行, 或是不全。我自己重新写了一份能运行的程序, 做了很多注释, 好好看看就能搞懂

#coding: utf-8

importselectimportsocketimportQueuefrom time importsleep#Create a TCP/IP

server =socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server.setblocking(False)#Bind the socket to the port

server_address = ('localhost', 8090)print ('starting up on %s port %s' %server_address)

server.bind(server_address)#Listen for incoming connections

server.listen(5)#Sockets from which we expect to read

inputs =[server]#Sockets to which we expect to write#处理要发送的消息

outputs =[]#Outgoing message queues (socket: Queue)

message_queues ={}whileinputs:#Wait for at least one of the sockets to be ready for processing

print ('waiting for the next event')#开始select 监听, 对input_list 中的服务器端server 进行监听

#一旦调用socket的send, recv函数，将会再次调用此模块

readable, writable, exceptional =select.select(inputs, outputs, inputs)#Handle inputs

#循环判断是否有客户端连接进来, 当有客户端连接进来时select 将触发

for s inreadable:#判断当前触发的是不是服务端对象, 当触发的对象是服务端对象时,说明有新客户端连接进来了

#表示有新用户来连接

if s isserver:#A "readable" socket is ready to accept a connection

connection, client_address =s.accept()print ('connection from', client_address)#this is connection not server

connection.setblocking(0)#将客户端对象也加入到监听的列表中, 当客户端发送消息时 select 将触发

inputs.append(connection)#Give the connection a queue for data we want to send

#为连接的客户端单独创建一个消息队列，用来保存客户端发送的消息

message_queues[connection] =Queue.Queue()else:#有老用户发消息, 处理接受

#由于客户端连接进来时服务端接收客户端连接请求，将客户端加入到了监听列表中(input_list), 客户端发送消息将触发

#所以判断是否是客户端对象触发

data = s.recv(1024)#客户端未断开

if data != '':#A readable client socket has data

print ('received "%s" from %s' %(data, s.getpeername()))#将收到的消息放入到相对应的socket客户端的消息队列中

message_queues[s].put(data)#Add output channel for response

#将需要进行回复操作socket放到output 列表中, 让select监听

if s not inoutputs:

outputs.append(s)else:#客户端断开了连接, 将客户端的监听从input列表中移除

#Interpret empty result as closed connection

print ('closing', client_address)#Stop listening for input on the connection

if s inoutputs:

outputs.remove(s)

inputs.remove(s)

s.close()#Remove message queue

#移除对应socket客户端对象的消息队列

delmessage_queues[s]#Handle outputs

#如果现在没有客户端请求, 也没有客户端发送消息时, 开始对发送消息列表进行处理, 是否需要发送消息

#存储哪个客户端发送过消息

for s inwritable:try:#如果消息队列中有消息,从消息队列中获取要发送的消息

message_queue =message_queues.get(s)

send_data= ''

if message_queue is notNone:

send_data=message_queue.get_nowait()else:#客户端连接断开了

print "has closed"

exceptQueue.Empty:#客户端连接断开了

print "%s" %(s.getpeername())

outputs.remove(s)else:#print "sending %s to %s " % (send_data, s.getpeername)

#print "send something"

if message_queue is notNone:

s.send(send_data)else:print "has closed"

#del message_queues[s]

#writable.remove(s)

#print "Client %s disconnected" % (client_address)

## Handle "exceptional conditions"

#处理异常的情况

for s inexceptional:print ('exception condition on', s.getpeername())#Stop listening for input on the connection

inputs.remove(s)if s inoutputs:

outputs.remove(s)

s.close()#Remove message queue

delmessage_queues[s]

sleep(1)

服务端

#coding: utf-8

importsocket

messages= ['This is the message', 'It will be sent', 'in parts', ]

server_address= ('localhost', 8090)#Create aTCP/IP socket

socks=[socket.socket(socket.AF_INET, socket.SOCK_STREAM), socket.socket(socket.AF_INET, socket.SOCK_STREAM), ]#Connect thesocket to the port where the server is listening

print ('connecting to %s port %s' %server_address)#连接到服务器

for s insocks:

s.connect(server_address)for index, message inenumerate(messages):#Send messages on both sockets

for s insocks:print ('%s: sending "%s"' % (s.getsockname(), message +str(index)))

s.send(bytes(message+ str(index)).decode('utf-8'))#Read responses on both sockets

for s insocks:

data= s.recv(1024)print ('%s: received "%s"' %(s.getsockname(), data))if data != "":print ('closingsocket', s.getsockname())

s.close()

客户端

一、select介绍

select()的机制中提供一fd_set的数据结构，实际上是一long类型的数组， 每一个数组元素都能与一打开的文件句柄(不管是Socket句柄，还是其他文件或命名管道或设备句柄)建立联系，建立联系的工作由程序员完成， 当调用select()时，由内核根据IO状态修改fd_set的内容，由此来通知执行了select()的进程哪一Socket或文件可读或可写。主要用于Socket通信当中。

总结：select主要用于socket通信当中，能监视我们需要的文件描述变化。

二、非阻塞式I/O编程特点

2.1、如果一个发现I/O有输入，读取的过程中，另外一个也有了输入，这时候不会产生任何反应.这就需要你的程序语句去用到select函数的时候才知道有数据输入。

2.2、程序去select的时候，如果没有数据输入，程序会一直等待，直到有数据为止，也就是程序中无需循环和sleep。

Select在Socket编程中还是比较重要的，可是对于初学Socket的人来说都不太爱用Select写程序，他们只是习惯写诸如connect、accept、recv或recvfrom这样的阻塞程序(所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回)。

可是使用Select就可以完成非阻塞(所谓非阻塞方式non-block，就是进程或线程执行此函数时不必非要等待事件的发生，一旦执行肯定返回，以返回值的不同来反映函数的执行情况，如果事件发生则与阻塞方式相同，若事件没有发生，则返回一个代码来告知事件未发生，而进程或线程继续执行，所以效率较高)方式工作的程序，它能够监视我们需要监视的文件描述符的变化情况——读写或是异常。

返回值：准备就绪的描述符数，若超时则返回0，若出错则返回-1。

三、示例

示例1：模拟select，同时监听多个端口

importsocketimportselect

sk1=socket.socket()

sk1.bind(('0.0.0.0', 8001))

sk1.listen()

sk2=socket.socket()

sk2.bind(('0.0.0.0', 8002))

sk2.listen()

sk3=socket.socket()

sk3.bind(('0.0.0.0', 8003))

sk3.listen()

inputs=[sk1, sk2, sk3, ]whileTrue:

r_list, w_list, e_list= select.select(inputs,[],inputs,1)for sk inr_list:#conn表示每一个连接对象

conn, address =sk.accept()

conn.sendall(bytes('hello', encoding='utf-8'))

conn.close()for sk ine_list:

inputs.remove(sk)

解释：#select内部自动监听sk1,sk2,sk3三个对象，监听三个句柄是否发生变化，把发生变化的元素放入r_list中。

#如果有人连接sk1，则r_list = [sk1]

#如果有人连接sk1和sk2，则r_list = [sk1,sk2]

#select中第1个参数表示inputs中发生变化的句柄放入r_list。

#select中第2个参数表示[]中的值原封不动的传递给w_list。

#select中第3个参数表示inputs中发生错误的句柄放入e_list。

#参数1表示1秒监听一次

#当有用户连接时，r_list里面的内容[]

服务端s1.py

importsocket

obj=socket.socket()

obj.connect(('127.0.0.1', 8001))

content= str(obj.recv(1024), encoding='utf-8')print(content)

obj.close()#客户端c2.py

importsocket

obj=socket.socket()

obj.connect(('127.0.0.1', 8002))

content= str(obj.recv(1024), encoding='utf-8')print(content)

obj.close()

客户端c1.py

示例2：IO多路复用--使用socket模拟多线程，并实现读写分离

#使用socket模拟多线程，使多用户可以同时连接

importsocketimportselect

sk1=socket.socket()

sk1.bind(('0.0.0.0', 8001))

sk1.listen()

inputs=[sk1, ]

outputs=[]

message_dict={}whileTrue:

r_list, w_list, e_list= select.select(inputs, outputs, inputs, 1)print('正在监听的socket对象%d' %len(inputs))print(r_list)for sk1_or_conn inr_list:#每一个连接对象

if sk1_or_conn ==sk1:#表示有新用户来连接

conn, address =sk1_or_conn.accept()

inputs.append(conn)

message_dict[conn]=[]else:#有老用户发消息了

try:

data_bytes= sk1_or_conn.recv(1024)exceptException as ex:#如果用户终止连接

inputs.remove(sk1_or_conn)else:

data_str= str(data_bytes, encoding='utf-8')

message_dict[sk1_or_conn].append(data_str)

outputs.append(sk1_or_conn)#w_list中仅仅保存了谁给我发过消息

for conn inw_list:

recv_str=message_dict[conn][0]delmessage_dict[conn][0]

conn.sendall(bytes(recv_str+'好', encoding='utf-8'))

outputs.remove(conn)for sk ine_list:

inputs.remove(sk)

服务端s1.py

importsocket

obj=socket.socket()

obj.connect(('127.0.0.1', 8001))whileTrue:

inp= input('>>>')

obj.sendall(bytes(inp, encoding='utf-8'))

ret= str(obj.recv(1024),encoding='utf-8')print(ret)

obj.close()

客户端c1.py

13:32:38