协程

协程,又称微线程,纤程,协程是一种用户态的轻量级线程
协程是单线程
协程的好处:
  • 1 没有上下文切换 因为协程只有一个线程,所有不用切换
  • 2 无需原子操作锁定及同步的开销 没有锁了,一个线程也不用锁
  • 3 方便切换控制流,简化编程模型
  • 4 高并发+高扩展性+低成本: 一个CPU支持上万的协程都不是问题,所以很适合用于高并发处理
缺点
无法利用多核资源:协程的本质是个单线程,它不能同时将单个CPU的多个核用上,协程需要和进程配合才能运行在多CPU上
有一个阻塞了,所有都阻塞
定义
必须在只有一个单线程里实现并发
修改共享数据不需加锁
用户程序里自己保存多个控制流的上下文栈
一个协程遇到IO操作自动切换到其它协程
  • yield支持下的协程

    import time
    import queue
    
    
    def consumer(name):
        print("--->starting ...")
        while True:
            new_baozi = yield               # 生成器
            print("[%s] is eating baozi %s" % (name, new_baozi))
            # time.sleep(1)
            # time.sleep(1)
    
    
    def producer():
        # r = con.__next__()      # r就是yield
        con.__next__()
        con2.__next__()
        n = 0
        while n < 1000:
            n += 1
            con.send(n)      # n发送到consumer里yield里,赋给new_baozi
            con2.send(n)
            print("\033[32;1m[producer]\033[0m is making baozi %s" % n)
    
    
    if __name__ == '__main__':
        con = consumer("c1")        # 创建生成器对象
        con2 = consumer("c2")       # 又创建一个生成器对象
        p = producer()              # 执行producer()函数 p是函数的返回值
    
  • genent支持的协程

    import gevent
    import time
    
    def foo():
        print('\033[31;1mRunning in foo\033[0m', time.ctime())
        gevent.sleep(1)             #  模拟IO阻塞
        print('\033[31;1mExplicit context switch to foo again\033[0m',time.ctime())
    
    
    def bar():
        print('\033[32;1mExplicit context to bar\033[0m')
        gevent.sleep(2)
        print('\033[32;1mImplicit context switch back to bar\033[0m',time.ctime())
    
    
    gevent.joinall([                # joinall 把两者连接起来
        gevent.spawn(foo),          # spawn 生产的意思
        gevent.spawn(bar),          # 遇到IO阻塞的时候切换
        # gevent.spawn(func3),
    ])
    
  • greenlet支持的协程

    # -*- coding:utf-8 -*-
    
    
    from greenlet import greenlet
    
    
    def test1():
        print(12)
        gr2.switch()
        print(34)
        gr2.switch()
    
    
    def test2():
        print(56)
        gr1.switch()
        print(78)
    
    
    gr1 = greenlet(test1)
    
    gr2 = greenlet(test2)
    
    gr1.switch()   # 谁调用switch()就切换到谁
    
  • 协程实现一个小爬虫

    import gevent
    from gevent import monkey
    monkey.patch_all()                  # 监听阻塞
    
    import ssl
    ssl._create_default_https_context = ssl._create_unverified_context
    
    from urllib.request import urlopen
    import time
    
    
    def f(url):
        print('GET: %s' % url)
        resp = urlopen(url)
        data = resp.read()
    
        # with open('xiaoahua.html', 'wb') as f:
        #     f.write(data)
    
        print('%d bytes received from %s.' % (len(data), url))
    
    
    # l = ['https://www.python.org/','https://www.yahoo.com/', 'https://github.com/']
    # start = time.time()
    # for url in l:
    #     f(url)
    # print(time.time()-start)
    
    
    
    start = time.time()
    
    gevent.joinall([
            gevent.spawn(f, 'https://www.python.org/'),
            gevent.spawn(f, 'https://www.yahoo.com/'),
            gevent.spawn(f, 'https://github.com/'),])
    
    print(time.time()-start)
    

推荐阅读更多精彩内容