并发编程之协程

并发的本质：切换+保存状态

cpu正在运行一个任务，会在两种情况下切走去执行其他的任务（切换由操作系统强制控制），一种情况是该任务发生了阻塞，另外一种情况是该任务计算的时间过长或有一个优先级更高的程序替代了它

如果多个任务都是纯计算的，线程间切换反而会降低效率

import time

# 串行执行
def consumer(res):
    pass

def producter():
    res = []
    for i in range(10000000):
        res.append(i)
    return res

start=time.time()
res=producter()
consumer(res)
stop=time.time()
print(stop-start)    # 1.2s


# 基于yield并发执行
def consumer():
    while True:
        x = yield

def producter():
    g = consumer()
    next(g)
    for i in range(10000000):
        g.send(i)

#基于yield保存状态,实现两个任务直接来回切换,即并发的效果
start = time.time()
producter()
stop = time.time()    # 1.5s
print(stop - start)

协程的本质就是在单线程下，由用户自己控制一个任务遇到io阻塞了就切换另外一个任务去执行，以此来提升效率
协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的

greenlet模块

from greenlet import greenlet

def eat(name):
    print('%s eat 1'%name)
    g2.switch('mike')
    print('%s eat 2'%name)
    g2.switch()

def play(name):
    print('%s play 1'%name)
    g1.switch()
    print('%s play 2'%name)

g1 = greenlet(eat)
g2 = greenlet(play)

g1.switch('mike') #可以在第一次switch时传入参数，以后都不需要

上例gevent.sleep(2)模拟的是gevent可以识别的io阻塞,
而time.sleep(2)或其他的阻塞,gevent是不能直接识别的需		
要用下面一行代码,打补丁,就可以识别了
from gevent import monkey;monkey.patch_all()必须放到被打补丁者的前面，如time，socket模块之前
或者我们干脆记忆成：要用gevent，需要将from gevent import monkey;monkey.patch_all()放到文件的开头

from gevent import monkey;monkey.patch_all()

import gevent
import time

def eat(name):
    print('%s eat 1'%name)
    time.sleep(2)
    print('%s eat 2'%name)

def play(name):
    print('%s play 1'%name)
    time.sleep(1)
    print('%s play 2'%name)

g1 = gevent.spawn(eat,'mike')
g2 = gevent.spawn(play,'mike')
g1.join()
g2.join()
# 或 gevent.joinall([g1,g2])
print('主')

通过gevent实现单线程下的socket并发

# （from gevent import monkey;monkey.patch_all()一定要放到导入socket模块之前，否则gevent无法识别socket的阻塞）
from gevent import monkey;monkey.patch_all()
from socket import *
import gevent

#如果不想用money.patch_all()打补丁,可以用gevent自带的socket
# from gevent import socket
# s=socket.socket()

def server(server_ip,port):
    s=socket(AF_INET,SOCK_STREAM)
    s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
    s.bind((server_ip,port))
    s.listen(5)
    while True:
        conn,addr=s.accept()
        gevent.spawn(talk,conn,addr)

def talk(conn,addr):
    try:
        while True:
            res=conn.recv(1024)
            print('client %s:%s msg: %s' %(addr[0],addr[1],res))
            conn.send(res.upper())
    except Exception as e:
        print(e)
    finally:
        conn.close()

if __name__ == '__main__':
    server('127.0.0.1',8080)

from threading import Thread
from socket import *
import threading

def client(server_ip,port):
    c=socket(AF_INET,SOCK_STREAM) #套接字对象一定要加到函数内，即局部名称空间内，放在函数外则被所有线程共享，则大家公用一个套接字对象，那么客户端端口永远一样了
    c.connect((server_ip,port))

    count=0
    while True:
        c.send(('%s say hello %s' %(threading.current_thread().getName(),count)).encode('utf-8'))
        msg=c.recv(1024)
        print(msg.decode('utf-8'))
        count+=1
if __name__ == '__main__':
    for i in range(5):
        t=Thread(target=client,args=('127.0.0.1',8080))
        t.start()

socketserver

import socketserver
'''
1 功能类
    class MyServer(socketserver.BaseRequestHandler):
        def handle(self):
            pass

2 server = socketserver.ThreadingTCPServer(('127.0.0.1',8880),MyServer)

3 server.serve_forever()

'''

class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        '''
        并发的业务逻辑
        :return:
        '''
        while 1:
            client_data = self.request.recv(1024)
            print(client_data.decode())
            if client_data.decode() == 'exit':
                print('客户端断开连接，等待新的用户连接...')
                break
            print('接收数据 >>>',str(client_data,'utf-8'))
            response = input('响应数据 >>>')
            self.request.sendall(bytes(response,'utf-8'))
        self.request.close()

server = socketserver.ThreadingTCPServer(('127.0.0.1',8880),MyServer)
server.serve_forever()

import socket

ip_port = ('127.0.0.1',8880)
sock = socket.socket()
sock.connect(ip_port)
print('客户端启动：')

while True:
    inp = input('发送数据 >>>')
    sock.sendall(bytes(inp,'utf-8'))
    if inp == 'exit':
        break
    server_response = sock.recv(1024)
    print('服务端响应数据 >>>',str(server_response,'utf-8'))