协程gevent模块和猴子补丁

时间：2021-08-19 21:33:44
# pip 装模块   greenlet和gevent

# 协程

    # 与进程、线程一样也是实现并发的手段

    # 创建一个线程、关闭一个线程都需要创建寄存器、栈等、需要消耗时间

# 协程本质上是一个线程

    # 能够在多个任务之间切换来节省一些IO时间

    # 协程中任务之间的切换时间开销，要远远小于进程或线程之间的切换

    # 4CPU中，进程一般创建4+1个进程 + 一个进程中线程为4*5 + 一个线程中创建500个协程，一般这是一台4CPU的机器电脑上能达到好的效率的并发程度，50000个并发。nginx这种负载均衡的东西就是这种思路

#

# def cosumer():

#     '''

#     生成器函数:

#     :return:

#     '''

#     while 1:

#         x = yield

#         print('处理消费了数据', x)

#

#

# if __name__ == '__main__':

#     c = cosumer()   # 得到生成器

#     next(c) # 走到生成器函数中的第一个yield

#     c.send(2)   # 将2给了生成器函数中的x并执行print然后又到了yield那

# # 在一个函数中控制另外一个函数，让这两个函数来回切换执行，下面用的是生成器实现的。协程效果

# def cosumer():

#     '''

#     生成器函数:

#     :return:

#     '''

#     while 1:

#         x = yield

#         print('处理消费了数据', x)

#

# def producer():

#     c = cosumer()

#     next(c)

#     for i in range(10):

#         print('生产了数据', i)

#         c.send(i)

#

# if __name__ == '__main__':

#     producer()

# 真正的协程实现任务之间的切换.

    # 真正的协程模块就是使用greenlet完成的任务之间的切换。省去了IO时间，当一个任务发生IO时，肯定会阻塞，此时这个时候去切换任务让另一个任务工作，另一个任务工作切换回来时，这个任务的IO时间正好结束，这就是协程想达到的效果，节省IO的切换时间

# import time

# from greenlet import greenlet

#

# def eat():

#     print('eating start')

#     g2.switch() # 切换到play中执行

#     print('eating end')

#

# def play():

#     print('playing start')

#     g1.switch() #切换到eat中执行

#

# g1 = greenlet(eat)  # eat任务放到greenlet中

# g2 = greenlet(play) # play任务放到greenlet中

# g1.switch() # 切换到eat任务执行到g2.switch()

# # 打印信息为

# # eating start

# # playing start

# # eating end

#

# # Process finished with exit code 0

# gevent模块

# import gevent

#

# def eat():

#     print('eating start')

#     gevent.sleep(1)   # 发生IO阻塞,切换到play

#     print('eating end')

#

# def play():

#     print('playing start')

#     gevent.sleep(1) # 发生IO阻塞,切换到eat

#

# g1 = gevent.spawn(eat)

# g2 = gevent.spawn(play)

# g1.join()   # 因为是异步的，如果不调用join，则直接执行到了下面，这样主进程就会结束，这里阻塞等待协程的结束

# g2.join()   

# gevent模块

# 协程，在一个线程中来回的切换。这个切换过程不是操作系统做的，而是gevent做的

# 在这个patch_all后面的所有模块中，发生的阻塞都会有gevent的效果

# #from gevent import monkey;monkey.patch_all()

# import time

# import gevent

#

# def eat():

#     print('eating start')

#     time.sleep(1)   # 发生IO阻塞,切换到play.因为有了mokey.patch_all所以这里等同于gevent.sleep(1)，遇见IO就会切换

#     print('eating end')

#

# def play():

#     print('playing start')

#     time.sleep(1) # 发生IO阻塞,切换到eat

#     print('playing end')

#

# if __name__ == '__main__':

#     g1 = gevent.spawn(eat)

#     g2 = gevent.spawn(play)

#     g1.join()   # 阻塞等待协程执行结束

#     g2.join()   # 

# 协程任务之间的切换由程序代码（gevent）完成，只有遇到协程模块能识别到的IO操作的时候，程序才会进行协程切换，实现并发的效果

# 同步和异步(协程实现)

from gevent import monkey;monkey.patch_all()  #猴子补丁，必须放到最前面，这样所有模块中的方法发生了IO阻塞时，就会触发协程的切换

import time

import gevent

def task():

    time.sleep(1)

    print(12345)

def sync():

    for i in range(2):

        task()

def async():

    g_lst = []

    for i in range(10):

        g = gevent.spawn(task)  # 创建协程

        g_lst.append(g)

    gevent.joinall(g_lst)   # 阻塞等待协程完毕

async() # 异步的打印12345

　　协程：能够在一个线程中实现并发效果的概念，能够巧妙的利用任务中的IO阻塞时间，在任务的执行过程中，检测到IO操作时就能够协程切换到别的任务中运行

相关文章