Python Select模型（程序流程）（转）

缘由 
之前写socket的CS模型代码，都是利用最原始的多线程方式。服务端是主线程，接到客户端的连接请求就从线程池中获取一个线程去处理整个socket连接的所有操作，虽然在连接数较短的情况下没有什么影响，但是当连接数很大的情况下，线程的切换和线程池的大小问题就明显起来了。

问题 
应该存在一种方式可以让一个线程去处理多个连接，在连接有事情做的时候才过去处理，不然的话线程就挂起，让线程的利用率更高，于是后来学习了select以及epoll。在这里我重点总结一下select

select的原理 
select是监听触发机制，监听可读和可写队列。当有事件发生时，进行遍历轮询事件发生的对象然后返回 
比如在服务端启动之后把服务端添加到select的可读监听队列中，当有客户端请求连接服务端时，select函数会返回一个可读事件再让服务端接受客户端的连接。 
select的返回方式可以是阻塞或者是非阻塞，非阻塞式的select处理方式是轮询的，会不断询问占用Cpu太多的资源和时间，所以建议使用阻塞等待返回的方式去使用select

优点： 
没有了多线程的创建、销毁、切换带来的效率和内存上的消耗 
缺点 
select存在一个最大可监听文件描述符数量，所以会收到最大连接监听的限制 
select在事件发生以后也是需要遍历监听对象，并不能直接定位到哪个对象，这个操作在对象数量庞大的情况下是个效率的瓶颈。所以后来有了epoll

程序流程描述： 
1. 在创建了server的socket以后，通过无限循环监听select事件执行相应的操作 
2. 客户端请求连接服务端，inputs非空，outputs为空，为queue增添客户端对象 ，readable非空，writeable为空 
3. 服务端接收客户端发送的数据，为outputs增添消息数据，readable不为空，writeable为空，如果接收失败说明客户端断开了连接，则终止监听此客户端的消息，回到第1步等待客户端连接 
4. outputs非空触发select事件，readable为空，writeable不为空，将queue中的数据发送到客户端，如果queue为空触发清除outputs操作 
5. 等待客户端发送数据，回到第2步

服务端代码：

#!/usr/bin/env python
#*-* coding:utf-8 *-*
import select
import socket
import Queue
import time
import os

class Server():
    #创建socket 套接字
    def __init__(self):
        self.server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        self.server.setblocking(False)
        #配置参数
        self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_address= ('127.0.0.1',8008)
        self.server.bind(self.server_address)
        self.server.listen(10)
        self.inputs = [self.server]
        self.outputs = []
        self.message_queues = {}
        #timeout = 20

    def run(self):
        while self.inputs:
            print "=================================="
            print "waiting for next event"
            print "inputs",self.inputs
            print "outputs",self.outputs
            print "queue", self.message_queues
        #readable , writable , exceptional = select.select(inputs, outputs, inputs, timeout)  最后一个是超时，当前连接要是超过这个时间的话，就会kill
            readable , writable , exceptional = select.select(self.inputs, self.outputs, self.inputs)
            print "readable , writable , exceptional",readable , writable , exceptional
            # When timeout reached , select return three empty lists
            if not (readable or writable or exceptional) :
                print "Time out ! "
                break;
            for s in readable :
                if s is self.server:
                    #通过self.inputs查看是否有客户端来
                    connection, client_address = s.accept()
                    print "    connection from ", client_address
                    connection.setblocking(0)
                    self.inputs.append(connection)
                    self.message_queues[connection] = Queue.Queue()
                else:
                    try:
                        data = s.recv(1024)
                    except:
                        print "  closing", client_address
                        if s in self.outputs :
                            self.outputs.remove(s)
                        self.inputs.remove(s)
                        s.close()
                        #清除队列信息
                        del self.message_queues[s]
                    else:
                        if data :
                            print " received " , data , "from ",s.getpeername()
                            self.message_queues[s].put(data)
                            # Add output channel for response
                            if s not in self.outputs:
                                self.outputs.append(s)
            for s in writable:
                try:
                    next_msg = self.message_queues[s].get_nowait()
                except Queue.Empty:
                    print " " , s.getpeername() , 'queue empty'
                    self.outputs.remove(s)
                else:
                    print " sending " , next_msg , " to ", s.getpeername()
                    os.popen('sleep 5').read()
                    s.send(next_msg)

            for s in exceptional:
                print " exception condition on ", s.getpeername()
                #stop listening for input on the connection
                self.inputs.remove(s)
                if s in self.outputs:
                    self.outputs.remove(s)
                s.close()
                #清除队列信息
                del self.message_queues[s]

if __name__ == "__main__":
    s = Server()
    s.run()

客户端代码：

# -*- coding:UTF-8 -*-
import socket
import os
import signal
import time, threading
def SendDataToServer(sock):
    while True:
        put = str(raw_input())
        sock.send(put)

def ReceiveData(sock):
    while True:
        try:
            data = sock.recv(1024)
            time.sleep(1)
        except:
            print "Server Down!"
            os._exit(0)
        else:
            if data:
                print "RECEIVE:",data

if __name__ == "__main__":
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect(('127.0.0.1', 8008))
    send_tick = threading.Thread(target=SendDataToServer, args=(s,))
    rec_tick = threading.Thread(target=ReceiveData, args=(s,))
    send_tick.start()
    rec_tick.start()