协程

import time
'''
协程：又称微线程，纤程。英文名Coroutine
优点1: 协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显
优点2: 不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多
因为协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能
'''
# yield的简单实现
# def consumer(name):
#  '''生成器'''
#  print('33[1;45m%s要开始吃包子了...33[0m' % name)
#  while True:
#     baozi = yield # send的值给了baozi这个变量
#     if baozi<51:
#        time.sleep(1)
#        print('33[1;33;41m%s在吃第%s个包子...33[0m' % (name, baozi))
#     else:
#        break
#
# def produser(name):
#  c1.__next__()
#  c2.__next__()
#  n = 1
#  while n<51:
#     try:
#        time.sleep(1)
#        print('33[1;31;43m%s正在做第%s和%s个包子...33[0m' % (name, n, n+1))
#        time.sleep(2)
#        print('%s说做好了两个包子你们快来吃...' % name)
#        c1.send(n)
#        c2.send(n+1)
#        n += 2
#     except Exception:
#        break
#
# if __name__ == '__main__':
#  c1 = consumer('小明')
#  c2 = consumer('小红')
#  produser('小梁')


# greenlet是一个用C实现的协程模块，相比与python自带的yield，它可以使你在任意函数之间随意切换，而不需把这个函数先声明为generator
# from greenlet import greenlet
# def test1():
#  print(12)
#  gr2.switch()
#  print(34)
#  gr2.switch()
#
# def test2():
#  print(56)
#  gr1.switch()
#  print(78)
#  gr1.switch()
#
# gr1 = greenlet(test1)
# gr2 = greenlet(test2)
# gr2.switch()



# 协程gevent
import gevent
import requests

start = time.time()

def f(url):
   print('GET:%s' % url)
   resp = requests.get(url)
   data = resp.text
   print('%d bytes received from %s.' % (len(data), url))

gevent.joinall([
   gevent.spawn(f, 'https://www.python.org/'),
   gevent.spawn(f, 'https://www.yahoo.com/'),
   gevent.spawn(f, 'https://www.baidu.com/'),
   gevent.spawn(f, 'https://www.sina.com.cn/'),
   gevent.spawn(f, 'http://www.xiaohuar.com/'),
])

# f('https://www.python.org/')
# f('https://www.yahoo.com/')
# f('https://www.baidu.com/')
# f('https://www.sina.com.cn/')
# f('http://www.xiaohuar.com/')

print('cost time:', time.time() - start)
# 协程：协作式，非抢占式的程序；yield(也算协程)；greenlet、gevent算是用户态的切换；协程主要解决的也是IO操作
# 协程本质上就是一个线程，优势：没有切换的消耗和没有锁的概念；是线程那就不能用多核，所以可以采用多进程+协程作为解决并发的方案(协程知识这只是一个开头)