• 博客整理day31


    pythonday31

    Event事件

    Event事件的作用:

    ​ 用来控制线程的执行

    ​ 由一些线程去控制另一些线程

    from threading import Event
    from threading import Thread
    import time
    
    #调用Event类实例化一个对象
    e = Event()
    
    #若该方法出现在任务中,则False阻塞  #e.wait()   #False
    #若该方法出现在任务中,则将其他线程的False改为True,进入就绪态与运行态  e.set()  #True
    
    def light():
        print('红灯...')
        time.sleep(1)
        #应该开始发送信号,告诉其他线程准备执行
        e.set()    #将car中的False ---> True
        print('绿灯...')
        
    def car(name):
        print('等红灯...')
        #让所有汽车进入阻塞
        e.wait()   #False
        print(f'{name}启动...')
        
    #让一个light线程任务控制多个car线程任务
    t = Thread(target = light)
    t.start()
    
    for line in range(10):
        t = Thread(target=car,args=(f'CART{line}'))
        t.start()
    

    线程池与进程池

    什么是进程池与线程池

    ​ 进程池与线程池是用来控制当前程序允许创建(进程/线程)的数量

    进程池与线程池的作用

    保证在硬件允许的范围内创建(进程/线程)的数量

    代码实现

    from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    import time
    
    #ProcessPoolExecutor(5)  #5代表只能开启5个进程,不填写,默认以CPU的个数限制进程数
    pool = ThreadPoolExecutor(5)  #代表5个线程,不填写,默认以CPU个数*5限制线程数
    
    def task():
        print('任务开始...')
        time.sleep(1)
        print('任务结束...')
       
    for line in range(5):
        pool.submit(task)
    

    回调函数

    from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    import time
    
    def task(res):
        print('任务开始...')
        time.sleep(1)
        print('任务结束...')
        return 123
    
    # 回调函数
    def call_back(res):
        print(type(res))
        res2 = res.result()
        print(res2)
    
    for line in range(5):
        pool.submit(task, 1).add_done_callback(call_back)
    

    协程

    协程的作用

    进程:资源单位

    线程:执行单位

    协程:在单线程下实现并发

    attention : 协程不是操作系统资源,它是程序起的名字,为了让单线程能实现并发

    协程的目的

    操作系统:

    ​ 操作系统下,线程具有多道技术,切换以及保存线程状态

    	1. 遇到IO事件
    	2. 当占用CPU执行时间过长
    

    协程:

    ​ 通过手动模拟操作系统的'多道技术',实现切换+保存状态

    ​ 手动实现遇到IO切换

    ​ 单线程遇到IO,切换+保存状态

    ​ 单线程计算密集型,来回切换+保存状态效率反而会降低

    优点:

    ​ 在IO密集的情况下,会提高效率

    缺点:

    ​ 若在计算密集的情况下来回切换,效率反而会降低

    协程的使用

    yield : yiled可以保存状态,yield的状态保存与操作系统的保存线程状态很像,

    ​ 但是yield是代码级别控制的,更轻量级

    并发: 切换

    #串行执行
    import time
    def consumer(res):
        '''任务1:接收数据,处理数据'''
        pass
    
    def producer():
        '''任务2:生产数据'''
        res=[]
        for i in range(10000000):
            res.append(i)
        return res
    
    start=time.time()
    #串行执行
    res=producer()
    consumer(res) #写成consumer(producer())会降低执行效率
    stop=time.time()
    print(stop-start) #1.5536692142486572
    
    
    
    #基于yield并发执行
    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()
    #基于yield保存状态,实现两个任务直接来回切换,即并发的效果
    #PS:如果每个任务中都加上打印,那么明显地看到两个任务的打印是你一次我一次,即并发执行的.
    producer()
    
    stop=time.time()
    print(stop-start) 
    
  • 相关阅读:
    Hdu 2564 单词缩写(字符串输入流的使用)
    Hdu2824 快速求欧拉函数和
    hdu 1787 欧拉函数模板
    Hdu2558(欧拉函数)
    hdu 1175连连看 (bfs带方向变化次数)
    pandas 使用总结
    APScheduler 定时任务使用总结
    watchdog 监控文件变化使用总结
    js 鼠标特效
    js 生成雪花间隔
  • 原文地址:https://www.cnblogs.com/samoo/p/11747996.html
Copyright © 2020-2023  润新知