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 开始监听
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import
select
import
socket
import
queue
import
sys
# Create a TCP/IP socket
server
=
socket.socket()
# set noblocking
server.setblocking(
False
)
# Bind the socket to the port
server_address
=
(
'localhost'
,
9999
)
print
(sys.stderr,
'starting up on %s port %s'
%
server_address)
server.bind(server_address)
# Listen for incoming connections
server.listen()
|
2.2 3个通信列表
select()方法接收并监控3个通信列表， 第一个是所有的输入的data,就是指外部发过来的数据，第2个是监控和接收所有要发出去的data(outgoing data),第3个监控错误信息，接下来我们需要创建2个列表来包含输入和输出信息来传给select()。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
import
select
import
socket
import
queue
import
sys
# Create a TCP/IP socket
server
=
socket.socket()
# set noblocking
server.setblocking(
False
)
# Bind the socket to the port
server_address
=
(
'localhost'
,
9999
)
print
(sys.stderr,
'starting up on %s port %s'
%
server_address)
server.bind(server_address)
# Listen for incoming connections
server.listen()
# 所有连接进来的对象都放在inputs
inputs
=
[server, ]
# 自己也要监控，因为server本身也是个对象
# 需要发送数据的对象
outputs
=
[]
|
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.
|
1
2
|
# 对外发送数据的队列，记录到字典中
message_queues
=
{}
|
2.4 主循环
|
1
2
3
|
while
True
:
readable, writable, exceptional
=
select.select(inputs, outputs, inputs)
# 如果没有任何fd就绪,那程序就会一直阻塞在这里
|
当你把inputs,outputs,exceptional(这里跟inputs共用)传给select()后，它返回3个新的list，我们上面将他们分别赋值为readable,writable,exceptional, 所有在readable list中的socket连接代表有数据可接收(recv),所有在writable list中的存放着你可以对其进行发送(send)操作的socket连接，当连接通信出现error时会把error写到exceptional列表中。
2.5 Readable list
Readable list 中的socket 可以有3种可能状态，第一种是如果这个socket是main "server" socket,它负责监听客户端的连接，如果这个main server socket出现在readable里，那代表这是server端已经ready来接收一个新的连接进来了，为了让这个main server能同时处理多个连接，在下面的代码里，我们把这个main server的socket设置为非阻塞模式。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
for
s
in
readable:
# 每一个s就是有个socket
if
s
is
server:
# 别忘记,上面我们server自己也当做一个fd放在了inputs列表里,传给了select,如果这个s是server,代表server这个fd就绪了,
# 就是有活动了, 什么情况下它才有活动? 当然 是有新连接进来的时候
# 新连接进来了,接受这个连接
conn, client_addr
=
s.accept()
print
(
"new connection from"
, client_addr)
conn.setblocking(
0
)
inputs.append(conn)
# 为了不阻塞整个程序,我们不会立刻在这里开始接收客户端发来的数据, 把它放到inputs里, 下一次loop时,这个新连接
# 就会被交给select去监听,如果这个连接的客户端发来了数据 ,那这个连接的fd在server端就会变成就续的,select就会把这个连接返回,
# 返回到readable 列表里,然后你就可以loop readable列表,取出这个连接,开始接收数据了, 下面就是这么干的
message_queues[conn]
=
queue.Queue()
# 接收到客户端的数据后,不立刻返回 ,暂存在队列里,以后发送
|
第二种情况是这个socket是已经建立了的连接，它把数据发了过来，这个时候你就可以通过recv()来接收它发过来的数据，然后把接收到的数据放到queue里，这样你就可以把接收到的数据再传回给客户端了。
|
1
2
3
4
5
6
7
8
|
else
:
# s不是server的话,那就只能是一个 与客户端建立的连接的fd了
# 客户端的数据过来了,在这接收
data
=
s.recv(
1024
)
if
data:
print
(
'received [%s] from %s'
%
(data, s.getpeername()[
0
]))
message_queues[s].put(data)
# 收到的数据先放到queue里,一会返回给客户端
if
s
not
in
outputs:
outputs.append(s)
# 为了不影响处理与其它客户端的连接 , 这里不立刻返回数据给客户端
|
第三种情况就是这个客户端已经断开了，所以你再通过recv()接收到的数据就为空了，所以这个时候你就可以把这个跟客户端的连接关闭了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
else
:
# 如果收不到data代表什么呢? 代表客户端断开了
print
(
"client [%s] closed"
, s)
if
s
in
outputs:
# 既然客户端都断开了，我就不用再给它返回数据了，
# 所以这时候如果这个客户端的连接对象还在outputs列表中，就把它删掉
outputs.remove(s)
inputs.remove(s)
# 这个连接必然在inputs中，也删掉
s.close()
# 关闭的连接在队列中也删除
del
message_queues[s]
|
2.6 writable list
对于writable list中的socket，也有几种状态，如果这个客户端连接在跟它对应的queue里有数据，就把这个数据取出来再发回给这个客户端，否则就把这个连接从output list中移除，这样下一次循环select()调用时检测到outputs list中没有这个连接，那就会认为这个连接还处于非活动状态
|
1
2
3
4
5
6
7
8
9
10
11
|
for
s
in
writable:
try
:
next_msg
=
message_queues[s].get_nowait()
except
queue.Empty:
# 没有数据了，该连接对象队列为空，停止检测
print
(
'output queue for [%s] is empty'
%
s.getpeername()[
0
])
outputs.remove(s)
else
:
print
(
'send %s to %s'
%
(next_msg, s.getpeername()[
0
]))
s.send(next_msg)
|
2.7 exceptional condition
最后，如果在跟某个socket连接通信过程中出了错误，就把这个连接对象在inputs\outputs\message_queue中都删除，再把连接关闭掉
|
1
2
3
4
5
6
7
8
9
10
|
for
s
in
exceptional:
print
(
'handling exceptional condition for'
, s.getpeername()[
0
])
# 从inputs中删除
inputs.remove(s)
if
s
in
outputs:
outputs.remove(s)
s.close()
# 删除队列
del
message_queues[s]
|
注： getpeername() / getsocketname
getpeername可以获得服务器的地址信息和端口号，正好和getsockname获得本机地址信息和端口号完全相反
三、完整事例
select server
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
# -*- coding: UTF-8 -*-
import
select
import
socket
import
queue
import
sys
# Create a TCP/IP socket
server
=
socket.socket()
# set noblocking
server.setblocking(
False
)
# Bind the socket to the port
server_address
=
(
'localhost'
,
9999
)
print
(sys.stderr,
'starting up on %s port %s'
%
server_address)
server.bind(server_address)
# Listen for incoming connections
server.listen()
# 所有连接进来的对象都放在inputs
inputs
=
[server, ]
# 自己也要监控，因为server本身也是个对象
# 需要发送数据的对象
outputs
=
[]
# 对外发送数据的队列，记录到字典中
message_queues
=
{}
while
True
:
readable, writable, exceptional
=
select.select(inputs, outputs, inputs)
# 如果没有任何fd就绪,那程序就会一直阻塞在这里
for
s
in
readable:
# 每一个s就是有个socket
if
s
is
server:
# 别忘记,上面我们server自己也当做一个fd放在了inputs列表里,传给了select,如果这个s是server,代表server这个fd就绪了,
# 就是有活动了, 什么情况下它才有活动? 当然 是有新连接进来的时候
# 新连接进来了,接受这个连接
conn, client_addr
=
s.accept()
print
(
"new connection from"
, client_addr)
conn.setblocking(
0
)
inputs.append(conn)
# 为了不阻塞整个程序,我们不会立刻在这里开始接收客户端发来的数据, 把它放到inputs里, 下一次loop时,这个新连接
# 就会被交给select去监听,如果这个连接的客户端发来了数据 ,那这个连接的fd在server端就会变成就续的,select就会把这个连接返回,
# 返回到readable 列表里,然后你就可以loop readable列表,取出这个连接,开始接收数据了, 下面就是这么干的
message_queues[conn]
=
queue.Queue()
# 接收到客户端的数据后,不立刻返回 ,暂存在队列里,以后发送
else
:
# s不是server的话,那就只能是一个 与客户端建立的连接的fd了
# 客户端的数据过来了,在这接收
data
=
s.recv(
1024
)
if
data:
print
(
'received [%s] from %s'
%
(data, s.getpeername()[
0
]))
message_queues[s].put(data)
# 收到的数据先放到queue里,一会返回给客户端
if
s
not
in
outputs:
outputs.append(s)
# 为了不影响处理与其它客户端的连接 , 这里不立刻返回数据给客户端
else
:
# 如果收不到data代表什么呢? 代表客户端断开了
print
(
"client [%s] closed"
, s)
if
s
in
outputs:
# 既然客户端都断开了，我就不用再给它返回数据了，
# 所以这时候如果这个客户端的连接对象还在outputs列表中，就把它删掉
outputs.remove(s)
inputs.remove(s)
# 这个连接必然在inputs中，也删掉
s.close()
# 关闭的连接在队列中也删除
del
message_queues[s]
for
s
in
writable:
try
:
next_msg
=
message_queues[s].get_nowait()
except
queue.Empty:
# 没有数据了，该连接对象队列为空，停止检测
print
(
'output queue for [%s] is empty'
%
s.getpeername()[
0
])
outputs.remove(s)
else
:
print
(
'send %s to %s'
%
(next_msg, s.getpeername()[
0
]))
s.send(next_msg)
for
s
in
exceptional:
print
(
'handling exceptional condition for'
, s.getpeername()[
0
])
# 从inputs中删除
inputs.remove(s)
if
s
in
outputs:
outputs.remove(s)
s.close()
# 删除队列
del
message_queues[s]
|
client
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# -*- coding: UTF-8 -*-
import
socket
HOST
=
'localhost'
# The remote host
PORT
=
9999
# The same port as used by the server
s
=
socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
while
True
:
msg
=
bytes(
input
(
">>:"
), encoding
=
"utf8"
)
s.sendall(msg)
data
=
s.recv(
1024
)
# print(data)
print
(
'Received'
,
repr
(data))
|
一、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，同时监听多个端口
import socket
import select
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, ]
while True:
r_list, w_list, e_list = select.select(inputs,[],inputs,1)
for sk in r_list:
# conn表示每一个连接对象
conn, address = sk.accept()
conn.sendall(bytes('hello', encoding='utf-8'))
conn.close()
for sk in e_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里面的内容[<socket.socket fd=220, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('0.0.0.0', 8001)>]
import socket
obj = socket.socket()
obj.connect(('127.0.0.1', 8001))
content = str(obj.recv(1024), encoding='utf-8')
print(content)
obj.close()
# 客户端c2.py
import socket
obj = socket.socket()
obj.connect(('127.0.0.1', 8002))
content = str(obj.recv(1024), encoding='utf-8')
print(content)
obj.close()
示例2：IO多路复用--使用socket模拟多线程，并实现读写分离
#使用socket模拟多线程，使多用户可以同时连接
import socket
import select
sk1 = socket.socket()
sk1.bind(('0.0.0.0', 8001))
sk1.listen()
inputs = [sk1, ]
outputs = []
message_dict = {}
while True:
r_list, w_list, e_list = select.select(inputs, outputs, inputs, 1)
print('正在监听的socket对象%d' % len(inputs))
print(r_list)
for sk1_or_conn in r_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)
except Exception 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 in w_list:
recv_str = message_dict[conn][0]
del message_dict[conn][0]
conn.sendall(bytes(recv_str+'好', encoding='utf-8'))
outputs.remove(conn)
for sk in e_list:
inputs.remove(sk)
import socket
obj = socket.socket()
obj.connect(('127.0.0.1', 8001))
while True:
inp = input('>>>')
obj.sendall(bytes(inp, encoding='utf-8'))
ret = str(obj.recv(1024),encoding='utf-8')
print(ret)
obj.close()
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 开始监听
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import
select
import
socket
import
queue
import
sys
# Create a TCP/IP socket
server
=
socket.socket()
# set noblocking
server.setblocking(
False
)
# Bind the socket to the port
server_address
=
(
'localhost'
,
9999
)
print
(sys.stderr,
'starting up on %s port %s'
%
server_address)
server.bind(server_address)
# Listen for incoming connections
server.listen()
|
2.2 3个通信列表
select()方法接收并监控3个通信列表， 第一个是所有的输入的data,就是指外部发过来的数据，第2个是监控和接收所有要发出去的data(outgoing data),第3个监控错误信息，接下来我们需要创建2个列表来包含输入和输出信息来传给select()。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
import
select
import
socket
import
queue
import
sys
# Create a TCP/IP socket
server
=
socket.socket()
# set noblocking
server.setblocking(
False
)
# Bind the socket to the port
server_address
=
(
'localhost'
,
9999
)
print
(sys.stderr,
'starting up on %s port %s'
%
server_address)
server.bind(server_address)
# Listen for incoming connections
server.listen()
# 所有连接进来的对象都放在inputs
inputs
=
[server, ]
# 自己也要监控，因为server本身也是个对象
# 需要发送数据的对象
outputs
=
[]
|
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.
|
1
2
|
# 对外发送数据的队列，记录到字典中
message_queues
=
{}
|
2.4 主循环
|
1
2
3
|
while
True
:
readable, writable, exceptional
=
select.select(inputs, outputs, inputs)
# 如果没有任何fd就绪,那程序就会一直阻塞在这里
|
当你把inputs,outputs,exceptional(这里跟inputs共用)传给select()后，它返回3个新的list，我们上面将他们分别赋值为readable,writable,exceptional, 所有在readable list中的socket连接代表有数据可接收(recv),所有在writable list中的存放着你可以对其进行发送(send)操作的socket连接，当连接通信出现error时会把error写到exceptional列表中。
2.5 Readable list
Readable list 中的socket 可以有3种可能状态，第一种是如果这个socket是main "server" socket,它负责监听客户端的连接，如果这个main server socket出现在readable里，那代表这是server端已经ready来接收一个新的连接进来了，为了让这个main server能同时处理多个连接，在下面的代码里，我们把这个main server的socket设置为非阻塞模式。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
for
s
in
readable:
# 每一个s就是有个socket
if
s
is
server:
# 别忘记,上面我们server自己也当做一个fd放在了inputs列表里,传给了select,如果这个s是server,代表server这个fd就绪了,
# 就是有活动了, 什么情况下它才有活动? 当然 是有新连接进来的时候
# 新连接进来了,接受这个连接
conn, client_addr
=
s.accept()
print
(
"new connection from"
, client_addr)
conn.setblocking(
0
)
inputs.append(conn)
# 为了不阻塞整个程序,我们不会立刻在这里开始接收客户端发来的数据, 把它放到inputs里, 下一次loop时,这个新连接
# 就会被交给select去监听,如果这个连接的客户端发来了数据 ,那这个连接的fd在server端就会变成就续的,select就会把这个连接返回,
# 返回到readable 列表里,然后你就可以loop readable列表,取出这个连接,开始接收数据了, 下面就是这么干的
message_queues[conn]
=
queue.Queue()
# 接收到客户端的数据后,不立刻返回 ,暂存在队列里,以后发送
|
第二种情况是这个socket是已经建立了的连接，它把数据发了过来，这个时候你就可以通过recv()来接收它发过来的数据，然后把接收到的数据放到queue里，这样你就可以把接收到的数据再传回给客户端了。
|
1
2
3
4
5
6
7
8
|
else
:
# s不是server的话,那就只能是一个 与客户端建立的连接的fd了
# 客户端的数据过来了,在这接收
data
=
s.recv(
1024
)
if
data:
print
(
'received [%s] from %s'
%
(data, s.getpeername()[
0
]))
message_queues[s].put(data)
# 收到的数据先放到queue里,一会返回给客户端
if
s
not
in
outputs:
outputs.append(s)
# 为了不影响处理与其它客户端的连接 , 这里不立刻返回数据给客户端
|
第三种情况就是这个客户端已经断开了，所以你再通过recv()接收到的数据就为空了，所以这个时候你就可以把这个跟客户端的连接关闭了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
else
:
# 如果收不到data代表什么呢? 代表客户端断开了
print
(
"client [%s] closed"
, s)
if
s
in
outputs:
# 既然客户端都断开了，我就不用再给它返回数据了，
# 所以这时候如果这个客户端的连接对象还在outputs列表中，就把它删掉
outputs.remove(s)
inputs.remove(s)
# 这个连接必然在inputs中，也删掉
s.close()
# 关闭的连接在队列中也删除
del
message_queues[s]
|
2.6 writable list
对于writable list中的socket，也有几种状态，如果这个客户端连接在跟它对应的queue里有数据，就把这个数据取出来再发回给这个客户端，否则就把这个连接从output list中移除，这样下一次循环select()调用时检测到outputs list中没有这个连接，那就会认为这个连接还处于非活动状态
|
1
2
3
4
5
6
7
8
9
10
11
|
for
s
in
writable:
try
:
next_msg
=
message_queues[s].get_nowait()
except
queue.Empty:
# 没有数据了，该连接对象队列为空，停止检测
print
(
'output queue for [%s] is empty'
%
s.getpeername()[
0
])
outputs.remove(s)
else
:
print
(
'send %s to %s'
%
(next_msg, s.getpeername()[
0
]))
s.send(next_msg)
|
2.7 exceptional condition
最后，如果在跟某个socket连接通信过程中出了错误，就把这个连接对象在inputs\outputs\message_queue中都删除，再把连接关闭掉
|
1
2
3
4
5
6
7
8
9
10
|
for
s
in
exceptional:
print
(
'handling exceptional condition for'
, s.getpeername()[
0
])
# 从inputs中删除
inputs.remove(s)
if
s
in
outputs:
outputs.remove(s)
s.close()
# 删除队列
del
message_queues[s]
|
注： getpeername() / getsocketname
getpeername可以获得服务器的地址信息和端口号，正好和getsockname获得本机地址信息和端口号完全相反
三、完整事例
select server
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
# -*- coding: UTF-8 -*-
import
select
import
socket
import
queue
import
sys
# Create a TCP/IP socket
server
=
socket.socket()
# set noblocking
server.setblocking(
False
)
# Bind the socket to the port
server_address
=
(
'localhost'
,
9999
)
print
(sys.stderr,
'starting up on %s port %s'
%
server_address)
server.bind(server_address)
# Listen for incoming connections
server.listen()
# 所有连接进来的对象都放在inputs
inputs
=
[server, ]
# 自己也要监控，因为server本身也是个对象
# 需要发送数据的对象
outputs
=
[]
# 对外发送数据的队列，记录到字典中
message_queues
=
{}
while
True
:
readable, writable, exceptional
=
select.select(inputs, outputs, inputs)
# 如果没有任何fd就绪,那程序就会一直阻塞在这里
for
s
in
readable:
# 每一个s就是有个socket
if
s
is
server:
# 别忘记,上面我们server自己也当做一个fd放在了inputs列表里,传给了select,如果这个s是server,代表server这个fd就绪了,
# 就是有活动了, 什么情况下它才有活动? 当然 是有新连接进来的时候
# 新连接进来了,接受这个连接
conn, client_addr
=
s.accept()
print
(
"new connection from"
, client_addr)
conn.setblocking(
0
)
inputs.append(conn)
# 为了不阻塞整个程序,我们不会立刻在这里开始接收客户端发来的数据, 把它放到inputs里, 下一次loop时,这个新连接
# 就会被交给select去监听,如果这个连接的客户端发来了数据 ,那这个连接的fd在server端就会变成就续的,select就会把这个连接返回,
# 返回到readable 列表里,然后你就可以loop readable列表,取出这个连接,开始接收数据了, 下面就是这么干的
message_queues[conn]
=
queue.Queue()
# 接收到客户端的数据后,不立刻返回 ,暂存在队列里,以后发送
else
:
# s不是server的话,那就只能是一个 与客户端建立的连接的fd了
# 客户端的数据过来了,在这接收
data
=
s.recv(
1024
)
if
data:
print
(
'received [%s] from %s'
%
(data, s.getpeername()[
0
]))
message_queues[s].put(data)
# 收到的数据先放到queue里,一会返回给客户端
if
s
not
in
outputs:
outputs.append(s)
# 为了不影响处理与其它客户端的连接 , 这里不立刻返回数据给客户端
else
:
# 如果收不到data代表什么呢? 代表客户端断开了
print
(
"client [%s] closed"
, s)
if
s
in
outputs:
# 既然客户端都断开了，我就不用再给它返回数据了，
# 所以这时候如果这个客户端的连接对象还在outputs列表中，就把它删掉
outputs.remove(s)
inputs.remove(s)
# 这个连接必然在inputs中，也删掉
s.close()
# 关闭的连接在队列中也删除
del
message_queues[s]
for
s
in
writable:
try
:
next_msg
=
message_queues[s].get_nowait()
except
queue.Empty:
# 没有数据了，该连接对象队列为空，停止检测
print
(
'output queue for [%s] is empty'
%
s.getpeername()[
0
])
outputs.remove(s)
else
:
print
(
'send %s to %s'
%
(next_msg, s.getpeername()[
0
]))
s.send(next_msg)
for
s
in
exceptional:
print
(
'handling exceptional condition for'
, s.getpeername()[
0
])
# 从inputs中删除
inputs.remove(s)
if
s
in
outputs:
outputs.remove(s)
s.close()
# 删除队列
del
message_queues[s]
|
client
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# -*- coding: UTF-8 -*-
import
socket
HOST
=
'localhost'
# The remote host
PORT
=
9999
# The same port as used by the server
s
=
socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
while
True
:
msg
=
bytes(
input
(
">>:"
), encoding
=
"utf8"
)
s.sendall(msg)
data
=
s.recv(
1024
)
# print(data)
print
(
'Received'
,
repr
(data))
|
一、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，同时监听多个端口
import socket
import select
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, ]
while True:
r_list, w_list, e_list = select.select(inputs,[],inputs,1)
for sk in r_list:
# conn表示每一个连接对象
conn, address = sk.accept()
conn.sendall(bytes('hello', encoding='utf-8'))
conn.close()
for sk in e_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里面的内容[<socket.socket fd=220, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('0.0.0.0', 8001)>]
import socket
obj = socket.socket()
obj.connect(('127.0.0.1', 8001))
content = str(obj.recv(1024), encoding='utf-8')
print(content)
obj.close()
# 客户端c2.py
import socket
obj = socket.socket()
obj.connect(('127.0.0.1', 8002))
content = str(obj.recv(1024), encoding='utf-8')
print(content)
obj.close()
示例2：IO多路复用--使用socket模拟多线程，并实现读写分离
#使用socket模拟多线程，使多用户可以同时连接
import socket
import select
sk1 = socket.socket()
sk1.bind(('0.0.0.0', 8001))
sk1.listen()
inputs = [sk1, ]
outputs = []
message_dict = {}
while True:
r_list, w_list, e_list = select.select(inputs, outputs, inputs, 1)
print('正在监听的socket对象%d' % len(inputs))
print(r_list)
for sk1_or_conn in r_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)
except Exception 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 in w_list:
recv_str = message_dict[conn][0]
del message_dict[conn][0]
conn.sendall(bytes(recv_str+'好', encoding='utf-8'))
outputs.remove(conn)
for sk in e_list:
inputs.remove(sk)
import socket
obj = socket.socket()
obj.connect(('127.0.0.1', 8001))
while True:
inp = input('>>>')
obj.sendall(bytes(inp, encoding='utf-8'))
ret = str(obj.recv(1024),encoding='utf-8')
print(ret)
obj.close()