协程

最新推荐文章于 2024-09-05 11:10:46 发布
最新推荐文章于 2024-09-05 11:10:46 发布
阅读量101 收藏
点赞数
文章标签： python 操作系统 运维
原文链接：http://www.cnblogs.com/-777/p/11421068.html
版权
协程

  1. 线程

    • 多线程抢占资源：只能让其串行

    1. 互斥锁

    2. 队列（三种）

    • 先进先出（Queue）
    import queue
q = queue.Queue(3)
q.put(1)
q.put(2)
q.put(3)
#q.put(4) 阻塞
print(p.get(block = False))
print(p.get())
print(p.get())
q.get(timeout = 2) #阻塞2s，还没有值就会报错
    • 先进后出，栈
    import queue
q = queue.LifoQueue(3)
q.put(1)
q.put(2)
q.put('alex')
print(q.get())
print(p.get())
print(p.get())
    • 优先级队列
    import queue
q = queue.PriorityQueue(4)
q.put((1,'元宝'))
q.put((0，'Gouhu'))
q.put((-1,'甘冈'))

  2. 事件(event)

    1. 版本一：程序中其他线程需要通过判断某一线程的状态来确定自己下一步的操作
    from threading import Thread
# from threading import current_thread
# import time
# flag = False
# def check():
#     print(f'{current_thread().name} 监测服务器是否开启... ')
#     time.sleep(3)
#     global flag
#     flag = True
#     print('服务器已经开启...')
# def connect():
#     while 1:
#         print(f'{current_thread().name} 等待连接...')
#         time.sleep(0.5)
#         if flag:
#             print(f'{current_thread().name} 连接成功...')
#             break
# t1 = Thread(target=check,)
# t2 = Thread(target=connect,)
# t1.start()
# t2.start()
    1. event
    from threading import Thread
from threading import Event
from threading import current_thread
import time
event = Event()
def check():
    print(f'{current_thread().name} 监测服务器是否开启...')
    time.sleep(3)
    print(event.is_set())#判断event内部标志位是否更改
    event.set()#更改event内部的标志位
    print(event.is_set())
    print(f'{current_thread().name} 服务器已经开启...')
def connect():
    print(f'{current_thread().name} 等待连接...')
    event.wait()#等待event内部标志位改变，再进行下面操作
    event.wait(1)#不报错，等待一秒，一秒之后如果还没有set直接进行下一步操作
    print(f'{current_thread().name} 连接成功...')
t1 = Thread(target=check,)
t2 = Thread(target=connect,)
t1.start()
t2.start()

    练习题：

    一个线程监测服务器是否开始,
# 另个一线程判断如果开始了,则显示连接成功,此线程只尝试连接3次,1s 一次,如果超过3次,还没有连接成功,则显示连接失败.
from threading import Thread
from threading import current_thread
from threading import Event
event = Event()
import time
def check():
 print(f'{current_thread().name} 监测服务器连接状态...')
 time.sleep(3)
 event.set()
 print(f'{current_thread().name}服务器已经开启...' )
def connect():
 count = 1
 while not event.is_set():
     if count == 4:
         print('连接失败...')
         break
     else:
         print(f'{current_thread().name} 尝试连接...')
         count += 1
         event.wait(1)
 print(f'{current_thread().name} 连接成功...')
t1 = Thread(target = check,)
t2 = Thread(target = connect,)
t1.start()
t2.start()

版本二：
from threading import Thread
# from threading import current_thread
# from threading import Event
# import time
#
# event = Event()
# def check():
#     print(f'{current_thread().name} 监测服务器是否开启...')
#     time.sleep(4)
#     event.set()
#     print('服务器已经开启...')
#
# def connect():
#     count = 1
#     while not event.is_set():
#         if count == 4:
#             print('连接次数过多,已断开')
#             break
#         event.wait(1)
#         print(f'{current_thread().name} 尝试连接{count}次')
#         count += 1
#     else:
#         print(f'{current_thread().name} 连接成功...')
#
# t1 = Thread(target=check,)
# t2 = Thread(target=connect,)
# t1.start()
# t2.start()

  3. 协程：一个线程并发的处理任务

    • 串行: 一个线程执行一个任务,执行完毕之后,执行下一个任务.

    • 并行: 多个cpu执行多个任务, 4个cpu 执行4个任务.

    • 并发: 一个cpu执行多个任务,看起来像是同时运行.并发真正的核心: 切换并且保持状态.

    • 多线程的并发: 3个线程处理10个任务,如果线程1处理的这个任务,遇到阻塞,cpu被操作系统切换到另一个线
      程,

    • 一个线程能否并发的处理任务??? 一个线程处理三个任务.
      单个cpu: 10个任务,让你给我并发的执行这个10个任务:

      1. 方式一:开启多进程并发执行, 操作系统切换+保持状态.

      2. 方式二:开启多线程并发执行,操作系统切换+保持状态.

      3. 方式三:开启协程并发的执行, 自己的程序 把控着cpu 在3个任务之间来回切换+保持状态.
        对3详细解释: 协程他切换速度非常快,蒙蔽操作系统的眼睛,让操作系统认为cpu一直在运行你这一个线程(协程.)

      4. 协程方式最好,为什么?

        ​ 开销小.

        ​ 运行速度快.

        ​ 协程会长期霸占cpu只执行我程序里面的所有任务.

        ​ 并发的本质:就是切换+保持状态.协程处理IO密集型, 计算密集型,还是串行好.什么是协程?

        ​ 单个线程并发的处理多个任务. 程序控制协程的切换+保持状态.
        ​ 协程的特点:必须在只有一个单线程里实现并发

        ​ 修改共享数据不需加锁

        ​ 用户程序里自己保存多个控制流的上下文栈(保持状态)

      5. 附加：一个协程遇到IO操作自动切换到其它协程
        工作中:一般在工作中我们都是进程+线程+协程的方式来实现并发，以达到最好的并发效果，如果是4核的cpu，一般起5个进程，每个进程中20个线程（5倍cpu数量），每个线程可以起500个协程，大规模爬取页面的时候，等待网络延迟的时间的时候，我们就可以用协程去实现并发。 并发数量 = 5 * 20 * 500 = 50000个并发，这是一般一个4cpu的机器最大的并发数。nginx在负载均衡的时候最大承载量就是5w个单线程里的这20个任务的代码通常会既有计算操作又有阻塞操作，我们完全可以在执行任务1时遇到阻塞，就利用阻塞的时间去执行任务2。。。。如此，才能提高效率，这就用到了Gevent模块。

    ```
    之前学的代码:有没有切换.

    切换

    def func1():

    print('in func1')

    def func2():

    print('in func2')

    func1()

    print('end')

    func2()

    切换 + 保持状态

    def gen():

    while 1:

    yield 1

    def func():

    obj = gen()

    for i in range(10):

    next(obj)

    func()

    上面的例子遇到IO不能自动切换

    import time

    def gen():

    while 1:

    yield 1

    time.sleep(0.5)

    def func():

    obj = gen()

    for i in range(10):

    next(obj)

    func()

    切换 +保持状态(遇到IO不会主动切换)

    from greenlet import greenlet

    import time

    def eat(name):

    print('%s eat 1' %name) # 2

    # g2.switch('taibai') # 3

    time.sleep(3)

    print('%s eat 2' %name) # 6

    g2.switch() # 7

    def play(name):

    print('%s play 1' %name) # 4

    g1.switch() # 5

    print('%s play 2' %name) # 8

    g1=greenlet(eat)

    g2=greenlet(play)

    g1.switch('taibai') # 1 切换到eat任务

    import time

    协程

    模拟的阻塞,不是真正的阻塞

    import gevent
    import time
    from threading import current_thread
    def eat(name):
    print(f'{name} eat 1')
    print(current_thread().name)
    gevent.sleep(2)
    # time.sleep(2)###不会切换
    print(f'{name} eat 2')
    def play(name):
    print(f'{name} play 1')
    print(current_thread().name)
    gevent.sleep(1)
    # time.sleep(1)
    print(f'{name} play 2')
    g1 = gevent.spawn(eat,'egon')
    g2 = gevent.spawn(play,name = 'egon')
    print(f'主{current_thread().name}')
    gevent.joinall([g1,g2])

    主MainThread
    egon eat 1
    MainThread
    egon play 1
    MainThread
    egon play 2
    egon eat 2

    最终版本:

    import gevent
    from gevent import monkey
    monkey.patch_all() # 打补丁: 将下面的所有的任务的阻塞都打上标记
    def eat(name):
    print(f'{name} eat 1')
    time.sleep(2)
    print(f'{name} eat 2')
    def play(name):
    print(f'{name} play 1')
    time.sleep(1)
    print(f'{name} play 2')
    g1 = gevent.spawn(eat,'egon')
    g2 = gevent.spawn(play,name = 'egon')
    gevent.joinall([g1,g2])

    egon eat 1
    egon play 1
    egon play 2
    egon eat 2

posted on 2019-08-27 21:48  七橼77 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/-777/p/11421068.html

aobai5662
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
协程库——面试问题
qq_44736340的博客
06-10 875
协程库项目面试问题
Kotlin 协程
canada_numbfish的博客
03-25 1058
属于Kotlin中非常有特色的一项技术，因为大部分编程语言中是没有协程这个概念的。那么什么是协程呢？它其实和线程是有点类似的，可以简单地将它理解成一种。要知道线程是非常重量级的，它需要依靠操作系统的调度才能实现不同线程之间的切换。而使用协程却可以仅在就能实现不同协程之间的切换，从而大大提升了并发编程的运行效率。
深入浅析python 协程与go协程的区别
01-20
【深入浅析Python协程与Go协程的区别】 在计算机科学中，进程、线程和协程是并发执行任务的三种基本方式。进程是程序在操作系统中的实例，包含内存空间和资源；线程是进程中的执行单元，是CPU调度的基本单位，同一...
C++ 开源协程库 libco——原理及应用1
08-03
【C++ 开源协程库 libco——原理及应用】 协程，作为一种轻量级的并发机制，近年来在编程领域中越来越受到重视。不同于传统的线程模型，协程不涉及昂贵的上下文切换，而是通过用户空间的协作来实现并发执行。C++ ...
详解Go多协程并发环境下的错误处理
12-16
如果协程A发生了panic，协程B是否会因为协程A的panic而挂掉？ 如果协程A发生了panic，协程B是否能用recover捕获到协程A的panic？ 答案分别是：会、不能。 那么下面我们来一一验证，并给出在具体的业务场景下的最佳...
c++ libgo 多协程ppt
05-05
C++中的多协程技术，特别是结合Libgo库的使用，是现代并发编程的重要手段。在C++中，多线程常用于实现并发，但线程间的上下文切换和同步锁带来的性能开销是其主要痛点。而协程，作为轻量级的执行单元，可以在单线程...
【python】—— Python爬虫实战：爬取珠海市2011-2023年天气数据并保存为CSV文件
weixin_63106307的博客
09-05 733
本文将介绍如何使用Python编写一个简单的爬虫程序，以爬取珠海市2011年至2023年的天气数据，并将这些数据保存为CSV文件。
JS都有哪些操作数组的方法
ggq53219的博客
09-04 444
JavaScript 中操作数组的方法非常丰富，这些方法大致可以分为几类：创建和初始化数组、添加元素、删除元素、遍历数组、搜索元素、数组排序、数组映射和过滤等。
Transiting from CUDA to HIP （二）
weixin_44500921的博客
09-03 1227
为了解决这个问题，HIP（Heterogeneous-compute Interface for Portability）提供了一套宏定义，使得开发者可以编写可移植的代码，这些代码可以在 NVIDIA 的 CUDA 平台和 AMD 的 ROCm 平台上运行。是一个预定义的宏，用于指示当前编译的代码所针对的 NVIDIA GPU 的计算能力（Compute Capability）。为了正确编译包含 HIP 代码的文件，您需要确保编译器能够找到 HIP 的头文件，并且定义了正确的宏。
asyncio note
weixin_48232453的博客
09-03 819
python异步库asyncio入门
【hot100篇-python刷题记录】【数据流的中位数】
m0_73629042的博客
09-04 281
精简的代码总是难以琢磨。
访问数组索引时超出边界引发 ArrayIndexOutOfBoundsException
最新发布
Itmastergo的博客
09-05 871
在 Java 中，数组是一种数据结构，用于存储固定数量的同类型元素。数组中的元素可以是基本数据类型（如intcharfloat等）或引用类型（如String、自定义类等）。数组是一种线性表数据结构，也就是说，数组中的元素可以通过一个整数索引来访问。数组的索引从0开始，这意味着对于长度为n的数组，合法的索引范围是从0到n-1。// 创建一个长度为 5 的整型数组在上面的例子中，numbers是一个包含 5 个整型元素的数组，索引从0到4。数组的大小在创建时就已经固定，因此无法动态扩展。
jupter_notebook简单介绍以及安装使用
Ctrl+CV九段手
09-02 1585
Jupyter如果工作主要涉及数据科学、机器学习、教育或需要创建可共享的交互式文档，Jupyter Notebook 是一个很好的选择。如果需要一个全面的开发环境来构建和维护大型的 Python 应用程序，或者正在从事软件工程项目，PyCharm 会更适合哦！
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 801
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
CUDA编程08 - 并行编程思维
GPU全栈博主-程序哥
09-02 1112
到目前为止，我们集中于学习并行编程的实用知识，包括CUDA编程接口特性、GPU架构、性能优化技术、并行模式和应用案例研究。在本章中，我们将讨论更为抽象的概念。我们将并行编程概括为一种思维过程，即设计或选择并行算法，并将一个实际问题分解基本的工作单元，这些工作单元可以由所选的算法高效地执行。具备强大思维技能的程序员不仅会分析问题，还会转变实际问题的结构：哪些部分本质上是串行的，哪些部分适合并行执行，以及将前者的部分转移到后者所涉及的一些权衡。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值