python之类之select

开始之前先上一个范例

select

# coding=utf-8
__author__ = 'hansz'
import socket
import select
import Queue
ip_port = ("127.0.0.1", 8809)
sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)
sk.setblocking(False)

inputs = [sk]
# input 变化的时候才感知

outputs = []
# outputs只要有值就能感知到。
# 所以当获取到客户端句柄到时候，发送完数据之后要从outputs里面移除

# 定义一个空字典 。用于客户端连接的时候
message = {}
#message = {
    #c1:"队列"，
    #c2:"队列"
#}
while True:
    Rlist, wlist, e = select.select(inputs, outputs, [], 5)
    # print "Rlist",len(Rlist)
    # print "inputs",len(inputs)
    # print w
    for r in Rlist:
        if r == sk:
            conn, address = r.accept()
            inputs.append(conn)
            print address
            message[conn] = Queue.Queue()
        else:
            client_data = r.recv(1024)
            if not client_data:
                inputs.remove(r)
            else:
                outputs.append(r)
                message[r].put(client_data)
                # 在指定队列插入数据


    for w in wlist:

        # w.sendall(client_data)
        # 如果这样写的话，有多个client连接的时候，client_data的值就会变。
        # 这样返回到值就会出错。
        # 利用队列，到相对应队列中取值。
        try:
            data = message[w].get_nowait()
            w.sendall(data)

        except Queue.Empty:
            pass
        outputs.remove(w)
        #del message[w]

select模块中的select函数是一个对底层操作系统的直接访问的接口。它用来监控sockets、files和pipes，等待IO完成。当有可读、可写或是异常事件产生时，select可以很容易的监控到。
select最大的好处就是可跨平台。差不多也是仅剩的好处了。

socket()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。

Python中的select模块以列表形式接受四个参数，分别是需要监控的可读文件对象，可写文件对象，产生异常的文件对象和超时设置，当监控的对象发生变化时，select会返回发生变化的对象列表。
监控的文件描述符是有个数限制的，在linux系统上是1024个。

poll

poll 和select差不多，但是没有个数限制。

epoll

epoll是在linux内核2.6之后出现的，所以只能用在linux内核大等于2.6的系统上。
下面是epoll的一个简单用法

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

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_address = ("192.168.1.5", 8080)
serversocket.bind(server_address)
serversocket.listen(1)
print  "服务器启动成功，监听IP：" , server_address
serversocket.setblocking(0)
timeout = 10
#新建epoll事件对象，后续要监控的事件添加到其中
epoll = select.epoll()
#添加服务器监听fd到等待读事件集合
epoll.register(serversocket.fileno(), select.EPOLLIN)
message_queues = {}

fd_to_socket = {serversocket.fileno():serversocket,}
while True:
  print "等待活动连接......"
  #轮询注册的事件集合
  events = epoll.poll(timeout)
  if not events:
     print "epoll超时无活动连接，重新轮询......"
     continue
  print "有" , len(events), "个新事件，开始处理......"
  for fd, event in events:
     socket = fd_to_socket[fd]
     #可读事件
     if event & select.EPOLLIN:
         #如果活动socket为服务器所监听，有新连接
         if socket == serversocket:
            connection, address = serversocket.accept()
            print "新连接：" , address
            connection.setblocking(0)
            #注册新连接fd到待读事件集合
            epoll.register(connection.fileno(), select.EPOLLIN)
            fd_to_socket[connection.fileno()] = connection
            message_queues[connection]  = Queue.Queue()
         #否则为客户端发送的数据
         else:
            data = socket.recv(1024)
            if data:
               print "收到数据：" , data , "客户端：" , socket.getpeername()
               message_queues[socket].put(data)
               #修改读取到消息的连接到等待写事件集合
               epoll.modify(fd, select.EPOLLOUT)
     #可写事件
     elif event & select.EPOLLOUT:
        try:
           msg = message_queues[socket].get_nowait()
        except Queue.Empty:
           print socket.getpeername() , " queue empty"
           epoll.modify(fd, select.EPOLLIN)
        else :
           print "发送数据：" , data , "客户端：" , socket.getpeername()
           socket.send(msg)
     #关闭事件
     elif event & select.EPOLLHUP:
        epoll.unregister(fd)
        fd_to_socket[fd].close()
        del fd_to_socket[fd]
epoll.unregister(serversocket.fileno())
epoll.close()
serversocket.close()