• 28 Apr 18 异步+回调 线程queue 线程event 协程(yield,greenlet,gevent)


    28 Apr 18
    一、异步+回调机制
    a、问题引入
    问题:
    1)任务的返回值不能得到及时的处理,必须等到所有任务都运行完毕才能统一进行处理
    2)解析的过程是串行执行的,如果解析一次需要花费2s,解析9次则需要花费18s
    from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    import os
    import requests
    import time
    import random
     
    def get(url):
        print('%s GET %s' %(os.getpid(),url))
        response=requests.get(url)
        time.sleep(random.randint(1,3))
        if response.status_code == 200:
            return response.text
     
    def pasrse(res):
        print('%s 解析结果为:%s' %(os.getpid(),len(res)))
     
    if __name__ == '__main__':
        urls=[
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.python.org',
        ]
        pool=ProcessPoolExecutor(4)
        objs=[]
        for url in urls:
            obj=pool.submit(get,url)
            objs.append(obj)
     
        pool.shutdown(wait=True)
     
        for obj in objs:
            res=obj.result()
            pasrse(res)
     
    b、进阶解决方案: 可以解决上述两个问题,但使得获取信息函数set和解析信息函数pasrse耦合到了一起
    from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    import requests
    import os
    import time
    import random
     
    def get(url):
        print('%s GET %s' %(os.getpid(),url))
        response=requests.get(url)
        time.sleep(random.randint(1,3))
     
        if response.status_code == 200:
            pasrse(response.text)
     
    def pasrse(res):
        print('%s 解析结果为:%s' %(os.getpid(),len(res)))
     
    if __name__ == '__main__':
        urls=[
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.python.org',
     
        ]
        pool=ProcessPoolExecutor(4)
        for url in urls:
            pool.submit(get,url)
     
    c1、终极解决方案: 可以解决上述两个问题,同时使获取信息函数set和解析信息函数pasrse解耦合(进程版)
    主进程作为回调的执行者
    from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    import requests
    import os
    import time
    import random
     
    def get(url):
        print('%s GET %s' %(os.getpid(),url))
        response=requests.get(url)
        time.sleep(random.randint(1,3))
     
        if response.status_code == 200:
            # 干解析的活
            return response.text
     
    def pasrse(obj):  #后续回调是obj会将自身传给pasrse,所以pasrse必须有且仅有一个参数
        res=obj.result()
        print('%s 解析结果为:%s' %(os.getpid(),len(res)))
     
    if __name__ == '__main__':
        urls=[
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.python.org',
        ]
     
        pool=ProcessPoolExecutor(4)
        for url in urls:
            obj=pool.submit(get,url)
            obj.add_done_callback(pasrse)
     
        print('主进程',os.getpid())
     
    c2、终极解决方案: 可以解决上述两个问题,同时使获取信息函数set和解析信息函数pasrse解耦合(线程版)
    哪个子进程空闲就由那个子进程作为回调的执行者
    from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    from threading import current_thread
    import requests
    import os
    import time
    import random
     
    def get(url):
        print('%s GET %s' %(current_thread().name,url))
        response=requests.get(url)
        time.sleep(random.randint(1,3))
     
        if response.status_code == 200:
            # 干解析的活
            return response.text
     
    def pasrse(obj):
        res=obj.result()
        print('%s 解析结果为:%s' %(current_thread().name,len(res)))
     
    if __name__ == '__main__':
        urls=[
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.baidu.com',
            'https://www.python.org',
        ]
        pool=ThreadPoolExecutor(4)
        for url in urls:
            obj=pool.submit(get,url)
            obj.add_done_callback(pasrse)
     
        print('主线程',current_thread().name)
     
    二、线程queue
    import queue
     
    q=queue.Queue(3) #队列:先进先出
    q.put(1)
    q.put(2)
    q.put(3)
    # q.put(4)       #阻塞
    print(q.get())
    print(q.get())
    print(q.get())
     
    q=queue.LifoQueue(3) #堆栈:后进先出
    q.put('a')
    q.put('b')
    q.put('c')
    print(q.get())
    print(q.get())
    print(q.get())
     
    q=queue.PriorityQueue(3) #优先级队列:可以以小元组的形式往队列里存值,第一个元素代表优先级,数字越小优先级越高
    q.put((10,'user1'))
    q.put((-3,'user2'))
    q.put((-2,'user3'))
    print(q.get())
    print(q.get())
    print(q.get())
     
    三、线程event
    a、案例一: 等待check重置event内的值后,connect从event.wait()后继续运行
    from threading import Event,current_thread,Thread
    import time
     
    event=Event()   #event内部维护着一个全局变量
     
    def check():
        print('%s 正在检测服务是否正常....' %current_thread().name)
        time.sleep(3)
        event.set() #改变event中的全局变量的值
     
    def connect():
        print('%s 等待连接...' %current_thread().name)
        event.wait() #等待全局变量的值被重置;如果括号中为1,即只等1秒
        print('%s 开始连接...' % current_thread().name)
     
    if __name__ == '__main__':
        t1=Thread(target=connect)
        t2=Thread(target=connect)
        t3=Thread(target=connect)
        c1=Thread(target=check)
        t1.start()
        t2.start()
        t3.start()
    c1.start()
     
    b、案例二:三次刷尝试后退出
    from threading import Event,current_thread,Thread
    import time
     
    event=Event()
     
    def check():
        print('%s 正在检测服务是否正常....' %current_thread().name)
        time.sleep(5)
        event.set()
     
    def connect():
        count=1
        while not event.is_set():
            if count ==  4:
                print('尝试的次数过多,请稍后重试')
                return
            print('%s 尝试第%s次连接...' %(current_thread().name,count))
            event.wait(1)
            count+=1
        print('%s 开始连接...' % current_thread().name)
     
    if __name__ == '__main__':
        t1=Thread(target=connect)
        t2=Thread(target=connect)
        t3=Thread(target=connect)
        c1=Thread(target=check)
        t1.start()
        t2.start()
        t3.start()
        c1.start()
     
    四、协程
    1、单线程下实现并发:协程 (为了提高效率;但不是说所有协程都会提升效率)
       并发指的多个任务看起来是同时运行的;并发实现的本质:切换+保存状态
       有效的协程在一定程度‘骗过’了CPU;通过自己内部协调,一遇到IO就切到自己的其他程序中,使得CPU以为这个程序一直在运行,从而使其更有可能处于就绪态或运行态,以更多的占用CPU。
    2、实现并发的三种手段:
    a)单线程下的并发;由程序自己控制,相对速度快
    b)多线程下的并发;由操作系统控制,相对速度较慢
    c)多进程下的并发;由操作系统控制,相对速度慢
     
    3、基于yield保存状态,实现两个任务直接来回切换,即并发的效果 (但yield不会遇到阻塞自动切程序)
       PS:如果每个任务中都加上打印,那么明显地看到两个任务的打印是你一次我一次,即并发执行的.
     
    import time
    def consumer():
        '''任务1:接收数据,处理数据'''
        while True:
            x=yield
     
    def producer():
        '''任务2:生产数据'''
        g=consumer()
        next(g)
        for i in range(10000000):
            g.send(i)
     
    start=time.time()
    producer() #1.0202116966247559
    stop=time.time()
    print(stop-start)
     
    # 纯计算的任务并发执行
    import time
    def task1():
        res=1
        for i in range(1000000):
            res+=i
            yield
            time.sleep(10000)  #yield不会自动跳过阻塞
            print('task1')
     
    def task2():
        g=task1()
        res=1
        for i in range(1000000):
            res*=i
            next(g)
            print('task2')
     
    start=time.time()
    task2()
    stop=time.time()
    print(stop-start)
     
    五、单线程下实现遇到IO切换
    1、 用greenlet(封装yield,遇到IO不自动切)
    from greenlet import greenlet
    import time
     
    def eat(name):
        print('%s eat 1' %name)
        time.sleep(30)
        g2.switch('alex')  #只在第一次切换时传值
        print('%s eat 2' %name)
        g2.switch()
    def play(name):
        print('%s play 1' %name)
        g1.switch()
        print('%s play 2' %name)
     
    g1=greenlet(eat)
    g2=greenlet(play)
    g1.switch('egon')
     
    2、 用gevent模块(封装greenlet,不处理的话,遇到自己的IO才主动切)
    import gevent
     
    def eat(name):
        print('%s eat 1' %name)
        gevent.sleep(5)  #换成time.sleep(5),不会自动切
        print('%s eat 2' %name)
    def play(name):
        print('%s play 1' %name)
        gevent.sleep(3)
        print('%s play 2' %name)
     
    g1=gevent.spawn(eat,'egon')
    g2=gevent.spawn(play,'alex')
     
    # gevent.sleep(100)
    # g1.join()
    # g2.join()
    gevent.joinall([g1,g2])
     
    3、 用gevent模块(封装greenlet,处理的话,遇到其他IO也主动切)
    from gevent import monkey;monkey.patch_all()
    from threading import current_thread
    import gevent
    import time
     
    def eat():
        print('%s eat 1' %current_thread().name)
        time.sleep(5)
        print('%s eat 2' %current_thread().name)
    def play():
        print('%s play 1' %current_thread().name)
        time.sleep(3)
        print('%s play 2' %current_thread().name)
     
    g1=gevent.spawn(eat)
    g2=gevent.spawn(play)
     
    # gevent.sleep(100)
    # g1.join()
    # g2.join()
    print(current_thread().name)
    gevent.joinall([g1,g2])
  • 相关阅读:
    如何将网页变成灰色的.
    页面中的传参介质(ViewState,Session,Items),Dictionary的用法.
    CSS控制Table单元格强制换行与强制不换行
    网页效果大集合
    结合ashx来在DataGrid中显示从数据库中读出的图片
    Atlas学习手记(29):JavaScript面向对象的扩展(三):接口Interface
    FormView中EditItemTemplate的注意事项
    javascript基本和常用的东西
    eclipse X11 xming 打造window下的linux c++开发环境
    转一篇软件测试方面的思考小文
  • 原文地址:https://www.cnblogs.com/zhangyaqian/p/py20180428.html
Copyright © 2020-2023  润新知