Python3-协程

‘‘‘
1、协程：
    单线程实现并发
    在应用程序里控制多个任务的切换+保存状态
    优点：
        应用程序级别速度要远远高于操作系统的切换
    缺点：
        多个任务一旦有一个阻塞没有切，整个线程都阻塞在原地
        该线程内的其他的任务都不能执行了

        一旦引入协程，就需要检测单线程下所有的IO行为,
        实现遇到IO就切换,少一个都不行，以为一旦一个任务阻塞了，整个线程就阻塞了，
        其他的任务即便是可以计算，但是也无法运行了

2、协程序的目的：
    想要在单线程下实现并发
    并发指的是多个任务看起来是同时运行的
    并发=切换+保存状态
‘‘‘

#串行执行
import time

def func1():
    for i in range(10000000):
        i+1

def func2():
    for i in range(10000000):
        i+1

start = time.time()
func1()
func2()
stop = time.time()
print(stop - start)


#基于yield并发执行
import time
def func1():
    while True:
        yield

def func2():
    g=func1()
    for i in range(10000000):
        i+1
        next(g)

start=time.time()
func2()
stop=time.time()
print(stop-start)

单纯地切换反而会降低运行效率

import time
def func1():
    while True:
        print(‘func1‘)
        yield

def func2():
    g=func1()
    for i in range(10000000):
        i+1
        next(g)
        time.sleep(3)
        print(‘func2‘)
start=time.time()
func2()
stop=time.time()
print(stop-start)

yield不能检测IO，实现遇到IO自动切换

import gevent
def eat(name):
    print(‘%s eat 1‘ %name)
    gevent.sleep(2)
    print(‘%s eat 2‘ %name)

def play(name):
    print(‘%s play 1‘ %name)
    gevent.sleep(1)
    print(‘%s play 2‘ %name)


g1=gevent.spawn(eat,‘egon‘)
g2=gevent.spawn(play,name=‘egon‘)
g1.join()
g2.join()
#或者gevent.joinall([g1,g2])
print(‘主‘)

from gevent import monkey
monkey.patch_all()
import socket
import gevent

def communicate(conn):
    while True:
        data = conn.recv(1024)
        if not data:
            break
        conn.send(data.upper())

def server(ip,port):
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((ip,port))
    server.listen(5)
    while True:
        conn, addr = server.accept()
        gevent.spawn(communicate, conn)
    server.close()

if __name__ == ‘__main__‘:
    g = gevent.spawn(server, ‘localhost‘, 9090)
    g.join()

from threading  import Thread
import socket
import threading

def client(server_ip, port):
    c = socket.socket(socket.AF_INET, socket.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(500):
        t = Thread(target=client, args=(‘localhost‘, 9090))
        t.start()