python自动化之路-day10

协程定义：
1.必须在只有一个单线程里实现并发
2.修改共享数据不要加锁
3.用户程序里自己保存多个控制流的上下文栈
4.一个协程遇到io操作自动切换到其他协程

greenlet是一个c实现的协程模块，相比于python自带的yield，它可以使你在任意
函数之间随意切换，而不需要吧这个函数先声明为generator

# -*- coding:utf-8 -*-
from greenlet import greenlet
# import greenlet
import time

def test1():
    print("tes1 函数_1")
    g2.switch()
    time.sleep(3)
    print("tes1 函数_2")
    g2.switch()


def test2():
    print("test2 函数_1")
    g1.switch()
    # time.sleep(1)
    print("test2 函数_2")


if __name__ == '__main__':
    g1=greenlet(test1)   #声明greenlet对象，参数可以是函数
    g2=greenlet(test2)
    g1.switch()   #直接切换到该greenlet对象

2.实例

协程：是一种用户态轻量级线程，
好处：无需线程上下文切换的开销，无需原子操作锁定以及同步的开销，方便切换控制流，
简化编程模型，高并发+高扩展+低成本：一个cpu支持上万的携程都不是问题。所以很适合用于高并发处理
缺点：无法利用多核资源，协程本质是一个单线程，它不能同时将单个cpu的多核用上，协程需要和进程配合
才能运行在多cpu上，当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
进行阻塞操作（blocking）如（IO时）会阻塞掉整个程序

# 使用yield实现协程的例子
import time
import queue
def consumer(name):
    print("--->starting eating baozi")
    while True:
        new_baozi = yield
        print("[%s] is eating [%s]"%(name,new_baozi))
def producer(name):
    print("--->starting making baozi")
    r1 =c1.__next__()
    r2 =c2.__next__()
    # print( c2.__next__())
    while True:
        print("[%s] is making baozi"%name)
        c1.send("baozi")
        c2.send("baozi")
        time.sleep(1)

if __name__ == '__main__':
    c1 = consumer("zhangsan_1")
    c2 = consumer("zhangsan_2")
    p = producer("lisi")

3.Gevent

"""
Gevent是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是
greenlet，它是以c扩展模块形式接入python的轻量级协程。greenlet全部运行在主程序操作系统
进程的内部，他们被协作式的调度。
在gevent里面，上下文切换是通过yielding来完成的. 在下面的例子里，
我们有两个上下文，通过调用gevent.sleep(1)，它们各自yield向对方。
"""
import gevent

def func1():
    print("\033[31;1m func1_1 \033[0m")
    gevent.sleep(3)
    print("\033[31;1m func1_2 \033[0m")

def func2():
    print("\033[31;1m func2_1 \033[0m")
    gevent.sleep(1)
    print("\033[31;1m func2_2 \033[0m")

gevent.joinall(    #相当于wait，咨询和
    [
        gevent.spawn(func1),
        gevent.spawn(func2)

    ]

)

4.同步异步性能区别

#_*_ coding:utf-8 _*_

import gevent

def task(pid):
    gevent.sleep(1)
    print("task %s done"%pid)

def sync():
    for i in  range(1,10):
        task(i)
def async():
    threads = [gevent.spawn(task,i)for i in  range(10)]
    gevent.joinall(threads)

print("sync")
sync()

print("----------->")

print("async")
async()

"""
上面程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。初始化的greenlet列表

存放在数组threads中，此数组被传给gevent.joinall 函数，后者阻塞当前流程，
并执行所有给定的greenlet。执行流程只会在 所有greenlet执行完后才会继续向下走。
"""

5.IO阻塞自动切换任务

实例：

#_*_ coding:utf-8 _*_
from urllib.request import urlopen
from gevent import monkey
monkey.patch_all()
import gevent

def f(url):
    print("GET:%s"%url)
    resp =urlopen(url)
    data = resp.read()
    print("%d bytes received from %s"%(len(data),url))

gevent.joinall(
    [
        gevent.spawn(f,"http://www.xiaohuar.com/"),
        gevent.spawn(f,"https://www.yahoo.com/"),
        gevent.spawn(f,"https://github.com/")
    ]
)

"""
爬虫简单程序
"""

gevent程序员指南：http://xlambda.com/gevent-tutorial/#_7