开发者

python基础之并发编程(三)

开发者 https://www.devze.com 2022-12-03 13:34 出处:网络 作者: 宠乖仪
目录一、协程定义和作用1、使用协程的优点2、使用协程的缺点二、Greenlet 的使用三、Gevent的使用四、async io 异步 IO1、asyncio中的task的使用五、总结进程与线程的区别:进程、线程和协程的特点总结一、协程定义和
目录
  • 一、协程定义和作用
    • 1、使用协程的优点
    • 2、使用协程的缺点
  • 二、Greenlet 的使用
    • 三、Gevent的使用
      • 四、async io 异步 IO
        • 1、asyncio中的task的使用
      • 五、总结
        • 进程与线程的区别:
        • 进程、线程和协程的特点
      • 总结

        一、协程定义和作用

        协程(coroutine),又称为微线程,纤程。(协程是一种用户态的轻量级线程)

        作用:在执行 A 函数的时候,可以随时中断,去执行 B 函数,然后中断继续执行 A 函数 (可以自动切换),单着一过程并不是函数调用(没有调用语句),过程很像多线程,然而协 程只有一个线程在执行

        python基础之并发编程(三)

        1、使用协程的优点

        由于自身带有上下文和栈,无需线程上下文切换的开销,属于程序级别的切换,操作系统 完全感知不到,因而更加轻量级;

        无需原子操作的锁定及同步的开销;

        方便切换控制流,简化编程模型

        单线程内就可以实现并发的效果,最大限度地利用 cpu,且可扩展性高,成本低(注:一 个 CPU 支持上万的协程都不是问题。所以很适合用于高并发处理)

        2、使用协程的缺点

        无法利用多核资源:协程的本质是个http://www.cppcns.com单线程,它不能同时将 单个 CPU 的多个核用上,协 程需要和进程配合才能运行在多 CPU 上.当然我们日常所编写的绝大部分应用都没有这个必 要,除非是 cpu 密集型应用。

        进行阻塞(Blocking)操作(如 IO 时)会阻塞掉整个程序

        # 协程的基本使用,  实现两个任务的切换         yield  和 next 来回切换
        def func1():
            for i in range(11):
                print(f"一班打印第{i}次数据")
                yield
        def func2():
            g = func1()
            next(g)
            for i in range(10):
                print(f"二班打印第{i}次数据")
                next(g)
        if __name__ == "__main__":
            func2()

        二、Greenlet 的使用

        单线程内有多个任务,用greenlet实现任务的切换 greenlet 和 switch 组合

        from greenlet import greenlet
        # pip install greenlet
        def gf(name):
            print(f'{name}:我想王者!!')
            g2.switch('zf')
            print(f'{name}:我想吃大餐!!!')
            g2.switch()
        def bf(name):
            print(f'{name}:一块去完!!!')
            g1.switch()
            print(f'{name}:一起去吃!!')
        if __name__ == "__main__":
            g1 = greenlet(gf)
            g2 = greenlet(bf)
            # 切换任务
            g1.switch('dc')   # 只需要第一次上传

        三、Gevent的使用

        Gevent 是一个第三方库,可以轻松通过 gevent 实现并发同步或异步编程,在 gevent 中用到的主要模式是 Greenlet,它是以 C 扩展模块形式接入 python 的轻量级协程。

        Grhttp://www.cppcns.comeenlet 全部运行在主程序操作系统进程的内部,但他们被协作式地调度。

        from gevent import monkey; # 为了能识别time模块的io
        monkey.patch_all()  #必须放到被打补丁者的前面,如 time,socket 模块之前
        import gevent
        # pip install gevent
        from time import time,sleep
        def gf(name):
            print(f'{name}:我想打王者!!')
            # gevent.sleep(2)
            sleep(2)
            print(f'{name}:我想吃大餐!!!')
        def bf(name):
            print(f'{name}:一起打!!!')
            # gevent.sleep(2)
            sleep(2)
            print(f'{name}:一快去吃!!')
        if __name__ == "__main__":
            start = time()
            # 创建协程对象
            g1 = gevent.spawn(gf,'貂蝉')
            g2 = gevent.spawn(bf,'吕布')
            # 开启任务
            g1.join()
            g2.join()
            www.cppcns.comend = time()
            print(end-start)

        注意:上例 gevent.sleep(2)模拟的是 gevent 可以识别的 io 阻塞; 而 time.sleep(2)或其他的阻塞,gevent 是不能直接识别的需要用下面一行代码,打补丁,就 可以识别了

        四、async io 异步 IO

        asyncio 是 python3.4 之后的协程模块,是 python 实现并发重要的包,这个包使用事件 循环驱动实现并发。

        事件循环是一种处理多并发量的有效方式,在维基百科中它被描述为「一种等待程序分配 事件或消息的编程架构」,我们可以定义事件循环来简化使用轮询方法来监控事件,通俗的说 法就是「当 A 发生时,执行 B」。

        • @asyncio.coroutine 协程装饰器装饰
        • asyncio.sleep() 可以避免事件循环阻塞
        • get_event_loop() 获取事件循环
        • Loop.run_until_complete() 监听事件循环
        • gather() 封装任务
        • await 等于 yield from 就是在等待 task 结果
        import asyncio
        @asyncio.coroutine # python3.5 之前 官网说3.10将被移除
        def func1():
            for i in range(5):
                print('一边吃饭!!')
                yield from asyncio.sleep(0)
        async def func2(): # python3.5以上
            for i in range(5):
                print('一边打游戏!!!')
                await asyncio.sleep(0)
        if __name__ == "__main__":
            g1 = func1()
            g2 = func2()
            # 获取事件循环
            loop = asyncio.get_event_loop()
            # 监听事件循环
            loop.run_until_complete(asyncio.gather(g1,g2))
            # 关闭事件循环
            loop.close()

        1、asyncio中的task的使用

        import asyncio
        import functoowww.cppcns.comls
        async def compute(x,y):
            print(f'compute:{x}+{y}....')
            await asyncio.sleep(1)
            return x+y
        async def print_sum(x,y):
            # 创建task
            task = asyncio.create_task(compute(x,y))        #python3.7以上写法
            # task绑定回调函数
            task.add_done_callback(functools.partial(end,x,y))  #python3.7以上写法
            # 释放下cpu的使用
            await asyncio.sleep(0)
            print('--------------------print_num继续执行---------------------------')
            for i in range(1000000):
                if i%5000 ==0:
                    print(i)
                    await asyncio.sleep(0.1)
        def end(n,m,t):
            print(f'{n}+{m}={t.result()}')
        if __name__ == "__main__":
            loop = asyncio.get_event_loop()
            loop.run_until_complete(print_sum(1,2))
            loop.close()

        五、总结

        并行:指的是任务数小于等于 cpu 核数,即任务真的是一起执行的

        并发:指的是任务数多余 cpu 核数,通过操作系统的各种任务调度算法,实现用多个任 务“一起”执行(实际上总有一些任务不在执行,因为切换任务的速度相当快,看上去一 起执行而已)

        进程与线程的区别:

        1. 线程是程序执行的最小单位,而进程是操作系统分配资源的最小单位;

        2. 一个进程由一个或多个线程组成,线程是一个进程中代码的不同执行路线;

        3. 进程之间相互独立,但同一进程下的各个线程之间共享程序的内存空间(包括代码段、 数据集、堆等)及一些进程级的资源(如打开文件和信号),某进程内的线程在www.cppcns.com其它进程 不可见;

        4. 调度和切换:线程上下文切换比进程上下文切换要快得多。

        进程、线程和协程的特点

        进程:拥有自己独立的堆和栈,既不共享堆,也不共享栈,进程由操作系统调度;进程切换需要的资源很最大,效率很低

        线程:拥有自己独立的栈和共享的堆,共享堆,不共享栈,标准线程由操作系统调度;线 程切换需要的资源一般,效率一般(当然了在不考虑 GIL 的情况下)

        协程:拥有自己独立的栈和共享的堆,共享堆,不共享栈,协程由程序员在协程的代码里 显示调度;协程切换任务资源很小,效率高

        多进程、多线程根据 cpu 核数不一样可能是并行的,但是协程是在一个线程中 所以是并发

        选择技术考虑的因素:切换的效率、数据共享的问题、 数据安全、是否需要并发

        总结

        本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

        0

        精彩评论

        暂无评论...
        验证码 换一张
        取 消

        关注公众号