python socket编程之select

引用：Python Select 解析:http://www.cnblogs.com/alex3714/p/4372426.html

引用：Python网络编程中的select 和 poll I/O复用的简单使用：http://www.cnblogs.com/coser/archive/2012/01/06/2315216.html

引用：Python socket编程 http://blog.sina.com.cn/s/blog_523491650100hikg.html

 

一、select，poll，epoll三者区别

 

二、select 服务端和客户端基本步骤

引用：Python socket编程 http://blog.sina.com.cn/s/blog_523491650100hikg.html

 

1）建立服务器连接需要六个步骤。

第1步，是创建socket对象。调用socket构造函数。

socket=socket.socket(familly,type)

family的值可以是AF_UNIX(Unix域，用于同一台机器上的进程间通讯)，也可以是AF_INET（对于IPV4协议的TCP和 UDP），

至于type参数，SOCK_STREAM（流套接字）或者 SOCK_DGRAM（数据报文套接字）,SOCK_RAW（raw套接字）。

 

 

第2步，则是将socket绑定（指派）到指定地址上。

socket.bind((host,port))

 

第3步，绑定后，必须准备好套接字，以便接受连接请求。

socket.listen(backlog)

acklog指定了最多连接数，至少为1，接到连接请求后，这些请求必须排队，如果队列已满，则拒绝请求。

 

 

第4步，服务器套接字通过socket的accept方法等待客户请求一个连接：

connection,address=socket.accept()

调用accept方法时，socket会进入'waiting'（或阻塞）状态。客户请求连接时，方法建立连接并返回服务器。

accept()返回：第一个元素（connection）是新的socket对象，服务器通过它与客户通信；第二个元素（address）是客户的internet地址。

 

第5步是处理阶段，服务器和客户通过send和recv方法通信（传输数据）。

服务器调用send，并采用字符串形式向客户发送信息。send方法返回已发送的字符个数。服务器使用recv方法从客户接受信息。

调用recv时，必须指定一个整数来控制本次调用所接受的最大数据量。recv方法在接受数据时会进入'blocket'状态，最后返回一个字符串，用它来表示收到的数据。如果发送的量超过recv所允许，数据会被截断。多余的数据将缓冲于接受端。以后调用recv时，多余的数据会从缓冲区删除。

 

第6步，传输结束，服务器调用socket的close方法以关闭连接

2）建立一个简单客户连接则需要4个步骤。

 

第1步，创建一个socket以连接服务器 socket=socket.socket(family,type)

 

第2步，使用socket的connect方法连接服务器 socket.connect((host,port))

 

第3步，客户和服务器通过send和recv方法通信。

 

第4步，结束后，客户通过调用socket的close方法来关闭连接。

 

 

三、select代码总体说明

3.1 使用select

在python中，select函数是一个对底层操作系统的直接访问的接口。它用来监控sockets、files和pipes，等待IO完成（Waiting for I/O completion）。当有可读、可写或是异常事件产生时，select可以很容易的监控到。 
select.select（rlist, wlist, xlist[, timeout]） 传递三个参数，一个为输入而观察的文件对象列表，一个为输出而观察的文件对象列表和一个观察错误异常的文件列表。第四个是一个可选参数，表示超时秒数。其返回3个tuple，每个tuple都是一个准备好的对象列表，它和前边的参数是一样的顺序。下面，主要结合代码，简单说说select的使用。 

3.2 select server端代码说明

一、select代码总结：

 

只要客户端发起一个新的socket过来，通过select监听这个句柄。

但是监听了之后，就用单线程处理了。

server端没有用到多线程。是监听有句柄（socket）过来（有连接活动过来）之后，

就用当前的这个处理了。它之所以看到的是异步的效果，是因为我们用了消息队列（Queue）减少阻塞。

但是所有的连接都是server端用单个线程处理的。

 

 

二、server端步骤：

1、该程序主要是利用socket进行通信，接收客户端发送过来的数据，然后再发还给客户端。 
2、首先建立一个TCP/IP socket，并将其设为非阻塞，然后进行bind和listen。 
3、通过select函数获取到三种文件列表，分别对每个列表的每个元素进行轮询，对不同socket进行不同的处理，最外层循环直到inputs列表为空为止 

4、如果从客户端的一个socket接收到数据，设置个字典变量（message_queues）就把这个socket作为key，value为一个队列，以便装这个socket的数据。

5、如果可以从活跃客户端的socket里读取数据：就往队列里put（从客户端socket接收到）的数据。

   如果能可以把数据写入到客户端，就从队列里get_nowait()，无阻塞方式读取队列里的数据，并发送给客户端的socket。
5、当设置timeout参数时，如果发生了超时，select函数会返回三个空列表。 并从message_queues字典里删除这个socket。关闭连接。

 

 

 

三、详细步骤：

inputs：从客户端读取(readable)的活跃的socket列表，先默认添加server

outputs：可以写入客户端(writable)的活跃的socket列表

 

while True:

readable, writable, exceptional = select.select(inputs, outputs, inputs,timeout)#第一次循环的时候inputs列表里已经有server

select.select（rlist, wlist, xlist[, timeout]） 传递三个参数，一个为输入而观察的文件对象列表，一个为输出而观察的文件对象列表和一个观察错误异常的文件列表。第四个是一个可选参数，表示超时秒数。其返回3个tuple，每个tuple都是一个准备好的对象列表，它和前边的参数是一样的顺序。下面，主要结合代码，简单说说select的使用。 

 

1）循环处理reatable列表：

情况1）server ready to connect client：准备建立连接--标识：

readable列表里有 server（因为inputs之前已经有server，如果,循环readable里有server的话，那么说明准备和一个客户端建立连接。）

connection, client_address = s.accept()

accept()返回：第一个元素（connection）是新的socket对象，服务器通过它与客户通信；第二个元素（address）是客户的internet地址

设成非阻塞模式：

connection.setblocking(0)

把inputs添加这个connection，也就是添加一个活跃可以读取数据的客户端socket。

把这个socket对象（connection），建一个我们以后可以发送数据的队列（queue）。

message_queues[connection] = Queue.Queue()#message_queues本是个空字典

情况2）server has connected:已经建立连接

接收数据

如果从可读取的客户端socket接收到数据的话：

我们就往队列里放个数据

message_queues[s].put(data)，#这里的s其实就是情况1准备建立连接的connection。情况1的时候，已经建立好队列了。

假如客户端socket不在可读取的列表里，就加入到列表了。

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

            并且，移除这个socket队列

 2）循环处理writable列表：

对于writable list中的socket，也有几种状态：

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

 

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

 

3.3 select client端代码说明

Client端创建多个socket进行server链接，用于观察使用select函数的server端如何进行处理。 

循环每个socket连接，给server发送和接收数据。

 

 

 

四、服务端完整代码及注释

代码，参见本地目录：E:\Python-10期\s10day7-biji\select_socket下的文件。

引用：Python Select 解析:http://www.cnblogs.com/alex3714/p/4372426.html

运行方法：在windows下运行server端程序，再开个窗口运行client端程序。然后观察server端和client端的输出。

 

#!/usr/bin/env python
#_*_coding:utf-8_*_
__author__ = 'WangQiaomei'


import select
import socket
import sys
import Queue

# Create a TCP/IP socket
'''
第1步是 创建socket对象。调用socket构造函数。
socket=socket.socket(familly,type)
family的值可以是AF_UNIX(Unix域，用于同一台机器上的进程间通讯)，也可以是AF_INET（对于IPV4协议的TCP和 UDP），
至于type参数，SOCK_STREAM（流套接字）或者 SOCK_DGRAM（数据报文套接字）,SOCK_RAW（raw套接字）。
'''
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setblocking(0)   #设置为非阻塞模式
'''
第2步，则是将socket绑定（指派）到指定地址上。
socket.bind((host,port))
'''

# Bind the socket to the port
server_address = ('localhost', 10000)
print >>sys.stderr, 'starting up on %s port %s' % server_address
server.bind(server_address)

# Listen for incoming connections
server.listen(5)
'''
inputs：从客户端读取(readable)的活跃的socket列表，先默认添加server
outputs：可以写入客户端(writable)的活跃的socket列表
'''
inputs = [server ]
outputs = []
message_queues = {}

while inputs:
    print >>sys.stderr, '\nwaiting for the next event'
    timeout = 1
    '''
    #第一次循环的时候inputs列表里已经有server
select.select（rlist, wlist, xlist[, timeout]） 传递三个参数，一个为输入而观察的文件对象列表，一个为输出而观察的文件对象列表和一个观察错误异常的文件列表。
第四个是一个可选参数，表示超时秒数。其返回3个tuple，每个tuple都是一个准备好的对象列表，它和前边的参数是一样的顺序。下面，主要结合代码，简单说说select的使用。
    '''
    readable,writable,exceptional = select.select(inputs, outputs, inputs,timeout)
    # Handle inputs
    #超时情况
    if not(readable or writable or exceptional):
        print >>sys.stderr, 'timed out , do something else here...'
        continue
    for s in readable:
        '''
        情况1）server ready to connect client：准备建立连接--标识：
            readable列表里有 server（因为inputs之前已经有server，如果,循环readable里有server的话，那么说明准备和一个客户端建立连接。）
      '''
        if s is server:
            # A "readable" server socket is ready to accept a connection
            #accept()返回：第一个元素（connection）是新的socket对象，服务器通过它与客户通信；第二个元素（address）是客户的internet地址
            connection, client_address = s.accept()
            print >>sys.stderr, 'new connection from', client_address
            connection.setblocking(0)  #设成非阻塞模式：
            inputs.append(connection)  #把inputs添加这个connection，也就是添加一个活跃可以读取数据的客户端socket。

            # Give the connection a queue for data we want to send
            '''
            #把这个socket对象（connection），建一个我们以后可以发送数据的队列（queue）。
            #message_queues本是个空字典
          '''
            message_queues[connection] = Queue.Queue()
        #情况2）server has connected:已经建立连接
        else:
            data = s.recv(1024) #接受数据
            if data:    #如果从可读取的客户端socket接收到数据的话：
                # A readable client socket has data
                print >>sys.stderr, 'received "%s" from %s' % (data, s.getpeername())
                '''
                我们就往队列里放个数据
                message_queues[s].put(data)，#这里的s其实就是情况1准备建立连接的connection。
                情况1的时候，已经建立好队列了。
              '''
                message_queues[s].put(data)
                # Add output channel for response
                #假如客户端socket不在可读取的列表里，就加入到列表了。
                if s not in outputs:
                    outputs.append(s)
            #情况3）就是这个客户端已经断开了，所以你再通过recv()接收到的数据就为空了，所以这个时候你就可以把这个跟客户端的连接关闭了。
            else:
                # Interpret empty result as closed connection
                print >>sys.stderr, 'closing', client_address, 'after reading no data'
                # Stop listening for input on the connection
                if s in outputs:
                    #既然客户端都断开了，我就不用再给它返回数据了，所以这时候如果这个客户端的连接对象还在outputs列表中，就把它删掉
                    outputs.remove(s) #如果存在，就从活跃可写入的socket列表里删除
                print 'wriatable---before::',writable
                if s in writable:
                    writable.remove(s) #如果存在，就从写入的列表里删除
                inputs.remove(s)       #活跃可读的socket列表里删除
                s.close()               #把连接关闭

                # Remove message queue
                del message_queues[s]   #移除这个socket队列
    print message_queues
    print 'wriatable:',writable
    # Handle outputs
    '''
    循环处理可写socket列表。
     如果有数据则发送回客户端，如果没数据则就把这个连接从output list中移除，outputs是活跃可写的socket列表。
     这样下一次循环select()调用时检测到outputs list中没有这个连接，那就会认为这个连接还处于非活动状态
     '''
    for s in writable:
        try:
            '''
            q.get([block[, timeout]]) 获取队列，timeout等待时间
            q.get_nowait() 相当q.get(False) 非阻塞
          '''
            next_msg = message_queues[s].get_nowait()
        except Queue.Empty:    #假如队列为空
            # No messages waiting so stop checking for writability.
            print >>sys.stderr, 'output queue for', s.getpeername(), 'is empty'
            outputs.remove(s)   #活跃可写socket列表删除此socket。
        else:                   #假如队列有数据
            print >>sys.stderr, 'sending "%s" to %s' % (next_msg, s.getpeername()) #客户端socket实例.getpeername()获取客户端的ip和端口
            s.send(next_msg)    #发送数据
    #最后，如果在跟某个socket连接通信过程中出了错误，就把这个连接对象在inputs\outputs\message_queue中都删除，再把连接关闭掉。
    # Handle "exceptional conditions"
    for s in exceptional:
        print >>sys.stderr, 'handling exceptional condition for', s.getpeername() #客户端socket实例.getpeername()获取客户端的ip和端口
        # Stop listening for input on the connection
        inputs.remove(s)        #活跃可读socket列表删除此socket。
        if s in outputs:
            outputs.remove(s)   #活跃可写socket列表删除此socket。
        s.close()               #连接关闭

        # Remove message queue
        del message_queues[s]   #从队列里删除。


'''
Python Select 解析:http://www.cnblogs.com/alex3714/p/4372426.html
'''

 

五、客户端完整代码及注释

#!/usr/bin/env python
#_*_coding:utf-8_*_

import socket
import sys

messages = [ 'This is the message. ',
             'It will be sent ',
             'in parts.',
             ]
server_address = ('localhost', 10000)

# Create a TCP/IP socket
socks = [ socket.socket(socket.AF_INET, socket.SOCK_STREAM),
          socket.socket(socket.AF_INET, socket.SOCK_STREAM),
          ]

# Connect the socket to the port where the server is listening
print >>sys.stderr, 'connecting to %s port %s' % server_address
for s in socks:
    s.connect(server_address)

for message in messages:

    # Send messages on both sockets
    '''
    s.getpeername()
    返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
    s.getsockname()
    返回套接字自己的地址。通常是一个元组(ipaddr,port)
    '''
    for s in socks:
        print >>sys.stderr, '%s: sending "%s"' % (s.getsockname(), message)     #s.getsockname() 返回socket自己的地址，发送消息
        s.send(message)

    # Read responses on both sockets
    for s in socks:
        data = s.recv(1024)     #默认最大文件描述符1024
        print >>sys.stderr, '%s: received "%s"' % (s.getsockname(), data)       #接受消息
        if not data:
            print >>sys.stderr, 'closing socket', s.getsockname()
            s.close()   #关闭链接。

'''
Python Select 解析:http://www.cnblogs.com/alex3714/p/4372426.html
'''

转载于:https://blog.51cto.com/wangqiaomei/1697892