协程，又称微线程，纤程，协程是一种用户态的轻量级线程

协程是单线程

协程的好处：

• 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)