day33-2 协程

目录

• 协程
  • 单线程实现并发
  • greenlet模块实现并发
  • gevent模块实现并发
    • 常用方法
    • 遇到IO阻塞时会自动切换任务
  • 协程与线程比较

协程

由于GIL锁导致在Cpython中多线程无法并行执行，只能并发执行。而并发实现的原理是切换+保存，那就意味着使用多线程实现并发，就需要为每一个任务创建一个线程

问题一：必然增加了线程创建销毁与切换带来的资源开销。

问题二：高并发情况下，由于任务数量太多导致无法开启新的线程，使得即没有实际任务要执行，也无法创建新线程来处理新任务的情况

所以应想办法避免创建线程带来的问题，同时又能保证并发效果，协程就是使用单线程来实现多任务并发

单线程实现并发

并发 = 切换任务+保存状态。python中的生成器就具备这样一个特点，每次调用next都会回到生成器函数中执行代码，并且是基于上一次运行的结果，这就意味着生成器会自动切换任务并保存执行状态

def task1():
    while True:
        yield
        print('task1 run')


def task2():
    g = task1()
    while True:
        next(g)
        print('task2 run')


task2()

并发虽然实现了，但是效率如何呢？

# 两个计算任务：一个采用生成器切换并发执行，一个直接串行调用
import time
def task1():
    a = 0
    for i in range(50000000):
        a += i
        yield


def task2():
    g = task1()
    b = 0
    for i in range(50000000):
        b += i
        next(g)


start_time = time.time()
task2()
print('spend time:', time.time() - start_time)
----------------------------------------------------------------
spend time: 15.74790096282959
 
----------------------------------------------------------------
import time
def task1():
    a = 0
    for i in range(50000000):
        a += i


def task2():
    b = 0
    for i in range(50000000):
        b += i


start_time = time.time()
task1()
task2()
print('spend time:', time.time() - start_time)
----------------------------------------------------------------
spend time: 5.204086065292358
# 单线程下串行执行两个计算任务，效率反而比并发高，因为并发需要不停的来回保存和切换

可以看出对于纯计算任务而言，单线程并发反而使执行效率下降了，所以单独使用协程并不适合处理计算型任务

greenlet模块实现并发

当处理多个任务时，使用yield编程实现并发十分混乱，因此有人用greenlet模块专门对yield进行了封装

import greenlet


def task1():
    for i in range(20):
        print('task1')
        t2.switch()  # 切换到任务t2


def task2():
    for i in range(20):
        print('task2')  
        t1.switch()  # 切换到任务t1


t1 = greenlet.greenlet(task1)
t2 = greenlet.greenlet(task2)
t1.switch()

该模块简化了yield复杂的代码结构，实现了单线程下多任务并发，但是无论是直接使用yield还是greenlet模块都不能在遇到IO时自动切换任务，所以就有了gevent模块。

gevent模块实现并发

常用方法

# 创建协程对象
g = gevent.spawn(func,*args,**kwargs)
# func是任务的函数名，args与kwargs为传入func中的不定长参数

g.join()  # 等待g结束再执行主线程
gevent.join((g1,g2))  # 等待g1，g2结束后再执行主线程

g.value()  # 拿到func的返回值

遇到IO阻塞时会自动切换任务

from gevent import monkey  # 导入monkey补丁
monkey.patch_all()  # 打补丁
import time
import gevent


def task1():
    print('task1 run....')
    time.sleep(3)
    print('task1 end....')


def task2():
    print('task2 run....')
    time.sleep(2)
    print('task2 end....')

g1 = gevent.spawn(task1)  
g2 = gevent.spawn(task2)

# 执行以上代码并不会有任何打印信息，因为协程任务都是以异步方式来提交，所以主线程会继续往下执行，执行完最后一行主线程也就结束了。导致了协程任务没有来的及执行，所以必须使用join来让主线程等待协程任务执行完毕
g1.join()
g2.join()

注意事项：

1.如果主进程结束了协程任务也会立即结束

2.monkey补丁的原理是把原始的阻塞方法替换为修改后的非阻塞方法

3.必须在打补丁后再使用相应的功能

协程与线程比较

协程：是在单线程下实现并发，又称作为微线程，纤程。是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的

线程：是属于内核级别的，由操作系统来控制调度(如单线程遇到IO或执行时间过长就会被迫交出cpu执行权限，切换到其他线程运行)

优点：

• 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
• 单线程内就可以实现并发的效果，最大限度地利用CPU

缺点：

• 协程本质是在单线程下实现并发，无法利用多核CPU。可以是一个程序开启多个进程，每个进程开启多个线程，每个线程内开启协程来尽可能提高效率
• 协程一旦出现阻塞，将会阻塞整个线程