python之socket编程（二）

标签（空格分隔）： socket编程

---

SocketServer解析

SocketServer内部使用I/O多路复用，多线程，多进程来实现客户端多并发访问Socket服务端，while循环时使用I/O多路复用，线程或进程和client端连接。

本图中，while循环就是用I/O多路复用。

我们先来看看I/O多路复用

I/O多路复用指：通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。

linux中的I/O多路复用

在Linux中，有三种I/O多路复用机制：select、poll、epoll
来看下历史：

select
 
select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。
select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点，事实上从现在看来，这也是它所剩不多的优点之一。
select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。
另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。
 
poll
 
poll在1986年诞生于System V Release 3，它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。
poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。
另外，select()和poll()将就绪的文件描述符告诉进程后，如果进程没有对其进行IO操作，那么下次调用select()和poll()的时候将再次报告这些文件描述符，所以它们一般不会丢失就绪的消息，这种方式称为水平触发（Level Triggered）。
 
epoll
 
直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。
epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。
epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。
另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。

三种机制的比较

机制名称	适用平台	是否for循环	监视描述符的数量
select	跨平台全兼容	使用for循环，效率低	1024
poll	跨平台全兼容	使用循环遍历文件描述符，效率低	无限制
epoll	只支持UNIX	不使用循环，使用边缘触发,效率高	无限制

Python中的I/O多路

Python中有一个select模块，其中提供了：select、poll、epoll三个方法，分别调用系统的 select，poll，epoll 从而实现IO多路复用。

系统	支持模式
windows	select
Mac	select
Linux	select/poll/epoll

网络操作、文件操作、终端操作等均属于IO操作，对于windows只支持Socket操作，其他系统支持其他IO操作，但是无法检测 普通文件操作 自动上次读取是否已经变化。

在socket中还有两点我们需要确定：

• I/O操作是不占用CPU的
• I/O多路复用用来监听socket对象内部是否变化了(连接或收发消息时候,socket对象内部发生变化)

我们先来看下select的用法吧：

句柄列表11, 句柄列表22, 句柄列表33 = select.select(句柄序列1, 句柄序列2, 句柄序列3, 超时时间)
 
参数： 可接受四个参数（前三个必须）
返回值：三个列表
 
select方法用来监视文件句柄，如果句柄发生变化，则获取该句柄。
1、当 参数1 序列中的句柄发生可读时（accetp和read），则获取发生变化的句柄并添加到 返回值1 序列中
2、当 参数2 序列中含有句柄时，则将该序列中所有的句柄添加到 返回值2 序列中，可利用此特性，做socket读写分离的测试
3、当 参数3 序列中的句柄发生错误时，则将该发生错误的句柄添加到 返回值3 序列中
4、当 超时时间 未设置，则select会一直阻塞，直到监听的句柄发生变化;当 超时时间 ＝1时，那么如果监听的句柄均无任何变化，则select会阻塞 1 秒，之后返回三个空列表，如果监听的句柄有变化，则直接执行。

那么我们用python中的select看下怎么实现I/O多路吧

多路复用实现socket伪并发

Client:

import socket

sk=socket.socket()
sk.connect(('127.0.0.1',9999))

msg=sk.recv(1024).decode()
print(msg)

while True:
    inp=input('>>:')
    sk.sendall(bytes(inp,encoding='utf8'))
sk.close()

Server:

import socket
import select

sk=socket.socket()      #用来接收客户端连接，
sk.bind(('127.0.0.1',9999,))
sk.listen(5)
inputs=[sk,]  #暂时先监听了sk一个对象，
while True:
    #I/O多路复用用来监听socket对象内部是否变化了
    rlist,w,e,=select.select(inputs,[],[],1)     #rlist为监听到的 发生变化socket对象 列表
    print(len(inputs),len(rlist))
    for r in rlist:
        #如果是新客户端来连接了
        if r == sk:
            print(r)
            conn,address=r.accept()     #conn用来接收消息，其实是一个socket对象，accept创建连接
            inputs.append(conn)
            conn.sendall(bytes('HELLO',encoding='utf8'))
        else:
            #否则，有人给我发消息了
            r.recv(1024)

server端中的select，是来

• 监听（服务端）对象，如果sk发生变化，表示有客户端来了，此时rlist值为[sk,]
• 监听conn对象，如果有消息发送过来，表示客户端有消息发送过来了，此时rlist值为[客户端，]

上面的代码执行后，可以看到rlist的变化，我们看下下一组代码：
client2:

sk=socket.socket()
sk.connect(('127.0.0.1',9998))

msg=sk.recv(1024).decode()
print(msg)

while True:
    inp=input('>>:')
    sk.sendall(bytes(inp,encoding='utf8'))
    print(sk.recv(1024).decode())
sk.close()

Server2:

import socket
import select

sk=socket.socket()
sk.bind(('127.0.0.1',9998,))
sk.listen(5)
inputs=[sk,]
outputs=[]
msg={}  #消息内容为{'obj':[msg1,msg2]}

while True:
    rlist,wlist,e,=select.select(inputs,outputs,[],1)
    print(len(inputs),len(rlist),len(wlist),len(outputs))
    for r in rlist:
        if r == sk:
            print(r)
            conn,address=r.accept()
            msg[conn]=[]
            inputs.append(conn)
            conn.sendall(bytes('HELLO',encoding='utf8'))
        else:   #接收消息并去除ioputs列表中断开的连接
            print('=====')
            try:
                res=r.recv(1024)
                if not res: #空消息断开
                    raise Exception('连接断开')
                else:
                    outputs.append(r)
                    msg[r].append(res)
            except Exception as e:
                inputs.remove(r)
                del msg[r]
    for w in wlist: #回消息
        res_msg=msg[r].pop()    #将消息拿出来
        res_p=res_msg+'response'
        w.sendall(bytes(res_p,encoding='utf8'))
        outputs.remove(w) #处理完成后去除对象，下一次不处理，如果不处理，会有异常，因为socket已关闭了

通过这一组代码，能看到发送消息和接受到消息时socket数量的变化，还是消息之间的交互。

银角在2.7中的解释,基于select实现socket服务端：

#!/usr/bin/env python
#coding:utf8

'''
 服务器的实现 采用select的方式
'''

import select
import socket
import sys
import Queue

#创建套接字并设置该套接字为非阻塞模式

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

#绑定套接字
server_address = ('localhost',10000)
print >>sys.stderr,'starting up on %s port %s'% server_address
server.bind(server_address)

#将该socket变成服务模式
#backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
#这个值不能无限大，因为要在内核中维护连接队列

server.listen(5)

#初始化读取数据的监听列表,最开始时希望从server这个套接字上读取数据
inputs = [server]

#初始化写入数据的监听列表，最开始并没有客户端连接进来，所以列表为空

outputs = []

#要发往客户端的数据
message_queues = {}
while inputs:
    print >>sys.stderr,'waiting for the next event'
    #调用select监听所有监听列表中的套接字，并将准备好的套接字加入到对应的列表中
    readable,writable,exceptional = select.select(inputs,outputs,inputs)#列表中的socket 套接字  如果是文件呢？ 
    #监控文件句柄有某一处发生了变化 可写 可读  异常属于Linux中的网络编程 
    #属于同步I/O操作，属于I/O复用模型的一种
    #rlist--等待到准备好读
    #wlist--等待到准备好写
    #xlist--等待到一种异常
    #处理可读取的套接字

    '''
        如果server这个套接字可读，则说明有新链接到来
        此时在server套接字上调用accept,生成一个与客户端通讯的套接字
        并将与客户端通讯的套接字加入inputs列表，下一次可以通过select检查连接是否可读
        然后在发往客户端的缓冲中加入一项，键名为:与客户端通讯的套接字，键值为空队列
        select系统调用是用来让我们的程序监视多个文件句柄(file descrīptor)的状态变化的。程序会停在select这里等待，
        直到被监视的文件句柄有某一个或多个发生了状态改变
        '''

    '''
        若可读的套接字不是server套接字,有两种情况:一种是有数据到来，另一种是链接断开
        如果有数据到来,先接收数据,然后将收到的数据填入往客户端的缓存区中的对应位置，最后
        将于客户端通讯的套接字加入到写数据的监听列表:
        如果套接字可读.但没有接收到数据，则说明客户端已经断开。这时需要关闭与客户端连接的套接字
        进行资源清理
        '''
        
    for s in readable: 
        if s is server:
            connection,client_address = s.accept()
            print >>sys.stderr,'connection from',client_address
            connection.setblocking(0)#设置非阻塞
            inputs.append(connection)
            message_queues[connection] = Queue.Queue()
        else:
            data = s.recv(1024)
            if data:
                print >>sys.stderr,'received "%s" from %s'% 
                (data,s.getpeername())
                message_queues[s].put(data)
                if s not in outputs:
                    outputs.append(s)
            else:
                print >>sys.stderr,'closing',client_address
                if s in outputs:
                    outputs.remove(s)
                inputs.remove(s)
                s.close()
                del message_queues[s]
                    
    #处理可写的套接字
    '''
        在发送缓冲区中取出响应的数据，发往客户端。
        如果没有数据需要写，则将套接字从发送队列中移除，select中不再监视
        '''

    for s in writable:
        try:
            next_msg = message_queues[s].get_nowait()

        except Queue.Empty:
            print >>sys.stderr,'  ',s,getpeername(),'queue empty'
            outputs.remove(s)
        else:
            print >>sys.stderr,'sending "%s" to %s'% 
            (next_msg,s.getpeername())
            s.send(next_msg)



    #处理异常情况

    for s in exceptional:
        for s in exceptional:
            print >>sys.stderr,'exception condition on',s.getpeername()
            inputs.remove(s)
            if s in outputs:
                outputs.remove(s)
            s.close()
            del message_queues[s]

I/O多路复用，适用于所有的I/O操作

这个是需要注意的，I/O多路复用适用于除文件操作外的所有I/O操作，支持终端。

ThreadingTCPServer

ThreadingTCPServer基础：

先看下ThreadingTCPServer如何使用：

• 创建一个继承自 SocketServer.BaseRequestHandler 的类
• 类中必须定义一个名称为 handle 的方法
• 启动ThreadingTCPServer

如下代码：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import SocketServer

class MyServer(SocketServer.BaseRequestHandler):

    def handle(self):
        # print self.request,self.client_address,self.server
        conn = self.request
        conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
        Flag = True
        while Flag:
            data = conn.recv(1024)
            if data == 'exit':
                Flag = False
            elif data == '0':
                conn.sendall('通过可能会被录音.balabala一大推')
            else:
                conn.sendall('请重新输入.')


if __name__ == '__main__':
    server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
    server.serve_forever()

依据上面的代码，我们可以来查看下ThreadingTCPServer的源码

ThreadingTCPServer的源码

先来看下执行顺序：

1. 创建一个SocketServer.ThreadingTCPServer对象(绑定IP和端口，和一个MyServer的类)
2. 创建对象后先执行ThreadingTCPServer的__init__构造方法，一直查找到BaseServer的__init__构造方法
3. 对象创建完成后,对象执行serve_forever的方法,查找serve_forever,查找到BaseServer的serve_forever方法
4. 查看serve_forever的的方法,执行_handle_request_noblock方法
5. _handle_request_noblock方法中调用process_request方法,查找对象的process_request,在ThreadingMixIn的方法中,也是创建多线程的时候
6. process_request方法中调用了ThreadingMixIn中的process_request_thread方法
7. process_request_thread方法中又调用了BaseServer中的finish_request方法.
8. finish_request方法中调用了RequestHandlerClass,进行查找,在刚开始进行查找的时候,我们会发现,创建对象时,参数MyServer已经是RequestHandlerClass
9. MyServer会执行构造方法__init__,查找会在BaseRequestHandler找到构造方法
10. 在BaseRequestHandler的构造方法中,会有self.handle()一句,执行MyServer中定义的hanler方法.

相关源码就不符了,直接在源码里找吧!最后把源码精简一下就是如下(copy自银角老师blog):

import socket
import threading
import select


def process(request, client_address):
    print request,client_address
    conn = request
    conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
    flag = True
    while flag:
        data = conn.recv(1024)
        if data == 'exit':
            flag = False
        elif data == '0':
            conn.sendall('通过可能会被录音.balabala一大推')
        else:
            conn.sendall('请重新输入.')

sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.bind(('127.0.0.1',8002))
sk.listen(5)

while True:
    r, w, e = select.select([sk,],[],[],1)
    print 'looping'
    if sk in r:
        print 'get request'
        request, client_address = sk.accept()
        t = threading.Thread(target=process, args=(request, client_address))
        t.daemon = False
        t.start()

sk.close()

如精简代码可以看出，SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 Threading 两个东西，其实本质上就是在服务器端为每一个客户端创建一个线程，当前线程用来处理对应客户端的请求，所以，可以支持同时n个客户端链接（长连接）。

多进程、多线程

一个应用程序，可以多进程、也可以多线程：
一个python脚本，默认是单进程，单线程的。
I/O操作（音频、视频、显卡操作），不占用CPU，所以：

• 对于I/O密集型操作，不会占用CPU，使用多线程操作，能提高效率
• 对于计算密集型操作，由于占用CPU，使用多进程操作，能提高效率

python中有个全局解释器锁，叫GIL（全称Global Interpreter Lock），导致一个进程只能由一个线程让CPU去调度,但在java c#可以使用多个线程。
多线程，多进程的目的，是为了提高并发，I/O密集型用多线程，计算密集型，用多进程。

我们来看看怎么创建多线程：

def f1(args):
     print(args)
import threading
t=threading.Thread(target=f1,args=(123,))    #创建一个线程，target表示线程执行的目标，args表示参数,是一个元组
t.start()     #并不代表当前立即被执行,系统来决定
f1(111)   

以上代码结果print顺序会随机！

更多的方法：

• start 不代表当前线程并不会立即被执行，而是等待CPU调度
• setName 为线程设置名称
• setDaemon(True) True表示主线程不等待子线程,执行完自己的任务后，自动关闭，子线程有可能未执行完毕。（默认情况下，主线程要等待子线程执行完毕后再关闭主线程）,True:后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止;False:前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
• join(2) 如果不想让线程并发的操作，表示主线程到此等待，等待直到子线程执行完毕。如果加上参数，表示主线程在此最多等几秒。该方法使得多线程变得无意义
• run 线程被cpu调度后自动执行线程对象的run方法

import time

def f1(args):
    time.sleep(5)
    print(args)

import threading
t1=threading.Thread(target=f1,args=(123,))
t1.setDaemon(True)  #表示主线程不等待子线程
t.start()     #并不代表当前被立即被执行,系统来决定
f1(111)

t.join(2) #表示主程序执行到此,等待...直到子线程执行完毕
print(222222)
print(333333)

待续...