Note5：网络编程之并发服务器（select,epoll,协程）

一，单进程服务器，非阻塞模式实现并发：

    windows下：

import socket

serverSocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
serverSocket.bind(('',8899))
serverSocket.listen(10)
serverSocket.setblocking(False)#设置serverSocket为非阻塞

conn_list = []

while True:
    try:
        conn, addr = serverSocket.accept()
    except Exception as e:
        pass
    else:
        print('client [%s] connect in...'%str(addr))
        conn.setblocking(False) #在保存之前，将其添加为非阻塞
        conn_list.append((conn,addr))

    for conn,addr in conn_list:
        try:
            data = conn.recv(1024)
        except BlockingIOError as e:
            pass
        except ConnectionResetError as e:
            #windos中如果客户端关闭套接字，会报连接重置异常，在linux中，recv会收到为‘’的数据
            print('client [%s] is lost...'%str(addr))
            conn.close()
            conn_list.remove((conn, addr))

        else:
                print('from [%s] message:%s'%(addr,data))

二，select服务器

    实现原理：

    select采用是轮询机制，意思是假如有100个套接字正在被select监听，那么select会一个一个地询问每个套接字是否收到数据，然后将收到数据的返回给redable一个列表。在32位系统中，可监听的套接字的上限为1024个。

    windows下：

import select
import socket

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind(('',8080))
server.listen(10)

inputs = [server,]

while True:

    #若没有链接或收到数据或有异常会处理阻塞
    readable,writeable,exceptional = select.select(inputs,[],[])
    #inputs:检测这个列表中的套接字是否可以收数据
    #中间的[]：检测这个列表中的套接字是否可发数据
    #右边的[]：检测这个列表中的套接字是否产生了异常


    for socket in readable:
        
        if socket==server:
            conn, addr = server.accept()
            print('a client [%s] connect in..'%str(addr))
            inputs.append(conn)
        else:
            try:
                data = socket.recv(1024)
                print('recv:%s'%data)
            except ConnectionResetError as e:
                print('a client is lost..')
                inputs.remove(socket)
                socket.close()

三，epoll服务器：

    实现原理：epoll采用事件通知机制，我们知道，轮询机制是轮流询问每个套接字是否要接收数据。这样效率其实是不高的。而事件通知机制是，监听的套接字如果要接收数据会主动通知epoll，这样就不用每个去挨着问了，就提高了效率。而且监听的套接字的个数是没有上限的。注意：epoll在windows下是没有的。

    linux下：

import socket
import select

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind(('',8080))
server.listen(10)

#创建一个epoll对象
epoll = select.epoll()

#注册一个事件到epoll中
#加select.EPOLLIN使套接字能够接收到数据
#EPOLLET边缘触发。当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理，下次不会通知。
epoll.register(server.fileno(),select.EPOLLIN | select.EPOLLET)

connections = {}
address = {}

while True:

	#epoll进行fd扫描
	p_list = epoll.poll()

	for fd, event in p_list:

		if fd==server.fileno():

			conn,addr = server.accept()

			print('a client [%s] connect in..'%str(addr))

			connections[conn.fileno()] = conn
			address[conn.fileno()] = addr

			epoll.register(conn.fileno(),select.EPOLLIN | select.EPOLLET)

		#若监听到有接收到数据的事件发生
		elif event==select.EPOLLIN:

			data = connections[fd].recv(1024)

			if data:
				print('recv from %s:%s'%(str(address[fd]),data))
			else:
				print('the client[%s] is lost..'%(str(address[fd])))

				epoll.unregister(fd)
				connections[fd].close()

四，协程

    什么是协程？协程就是微线程，即在单线程下通过快速地上下文切换而实现的并发现象。比如，一个人想同时干两件事，如果他的速度很快的话，他0.1秒切换到另一个任务上去，再0.1秒切换另一件事上去，那么普通人看的话他就是在同时干两件事。

    1.通过yield来实现协程

import time
def Consume(name):
    print('[%s]准备吃包子了'%name)
    while True:
        baozi = yield
        print('包子[%s]来了，[%s]吃了一半...'%(baozi,name))

def Produce():
    c1 = Consume('bob')
    c2 = Consume('linda')
    c1.__next__()
    c2.__next__()
    for i in range(10):
        time.sleep(1)
        print('第[%s]个包子做好了'%(i+1))
        c1.send(i)
        c2.send(i)
if __name__ == '__main__':
    Produce()

    2.greenlet版协程

    注意：greenlet模块需要自己就手动安装(我用的是python3)

    ubuntu下安装：sudo pip3 install greenlet

from greenlet import greenlet
#遇到switch就切换任务

def f1():
    print(1)
    g2.switch()#切换到f2
    print(3)
    g2.switch()

def f2():
    print(2)
    g1.switch()#切换到f1
    print(4)
    
if __name__ == '__main__':
    g1 = greenlet(f1)
    g2 = greenlet(f2)
    g1.switch()

    3.gevent版协程

import gevent
def fun1():
    print('-----fun1--a----')
    gevent.sleep(5)
    print('-----fun1--b----')
def fun2():
    print('-----fun2--a----')
    gevent.sleep(1)
    print('-----fun2--b----')
def fun3():
    print('-----fun3--a----')
    gevent.sleep(2)
    print('-----fun3--b----')

if __name__ == '__main__':
    gevent.joinall([
        gevent.spawn(fun1),
        gevent.spawn(fun2),
        gevent.spawn(fun3)
    ])
#gevent协程只要有耗时操作就切换任务

    4.gevent实现并发服务器

from gevent import socket,monkey  #用gevent里的socket，遇到阻塞才会切换任务
import gevent
import socket

#给程序打上补丁
monkey.patch_all()


def handle_request(conn):
    while True:
        try:
            receive_data = conn.recv(1024)
            print(receive_data)
            conn.sendall(receive_data)
        except Exception as e:
            print(e)
            break
def server(host,port):
    s = socket.socket()
    s.bind((host,port))
    s.listen(100)
    while True:
        # 遇到阻塞就切换到handle_request里处理，handle_request执行到recv若阻塞
        #就回到accept这个位置执行。也就是在监听是否有套接字连进来和recv接收数据两个事件里不断切换
        #如果速度很快，就好像在同时发生。
        conn,addr = s.accept() 
        print('%s连接进来'%conn)
        gevent.spawn(handle_request,conn)

if __name__ == '__main__':
    server('localhost',9000)