Python semaphore evevt生产者消费者模型原理解析

线程锁相当于同时只能有一个线程申请锁，有的场景无数据修改互斥要求可以同时让多个线程同时运行，且需要限制并发线程数量时可以使用信号量

import threading, time, queue

def test(name):
  semaphore.acquire() #获取信号量锁
  print('my name is %s' %name)
  time.sleep(1)
  semaphore.release() #释放信号量锁

semaphore = threading.BoundedSemaphore(5) #创建一个信号量同时可以运行3个线程
for i in range(20):
  t = threading.Thread(target=test, args=(i,))
  t.start()
while threading.active_count() == 1:
  print("all run done")

两个或者多个线程需要交互时，且一个进程需要根据另一线程状态执行对应操作时，可以通过event来设置线程状态达到期望的效果，下面是一个红绿灯的例子

event = threading.Event() #实例化一个event
def light():
  while True:
    print("红灯亮了，请停车")
    time.sleep(20) #开始是红灯20s
    event.set() #红灯时间到了，设置标志位
    print("绿灯亮了，请通行")
    time.sleep(30) #持续30s红灯
    event.clear() #清空标志位

def car(num):
  while True:
    if event.is_set():#检测event被设置则执行
      print("car %s run"%num)
      time.sleep(5)
    else:
      print("this is red light waiting")
      event.wait() #此处会卡主，直到状态被设置才会向下执行

Light = threading.Thread(target=light,)
Light.start()
for i in range(10):
  Car = threading.Thread(target=car, args=(i,))
  Car.start()

当多个线程需要交互数据可以使用queue来进行数据传递，下面是经典的生产者消费者多线程模型示例，其中包含线程queue的基本使用方法

my_queue = queue.Queue() #实例化一个队列
queue1 = queue.LifoQueue() #后进 先出队列
queue2 = queue.PriorityQueue() #带优先级的队列
def pro():
  for i in range(100):
    my_queue.put(i) #队列里面放数据
def con():
  while my_queue.qsize() > 0: #当队列有数据时候从队列取数据
    print("i an a consumer,get num %s"%my_queue.get(timeout=3))
    time.sleep(2)
  else:
    print("my queue is empty")

Pro = threading.Thread(target=pro)
Pro.start()

for j in range(10):
  Con = threading.Thread(target=con)
  Con.start()

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

赞 (0)

相关推荐

  • Python多进程同步Lock、Semaphore、Event实例

    同步的方法基本与多线程相同. 1) Lock 当多个进程需要访问共享资源的时候,Lock可以用来避免访问的冲突. 复制代码 代码如下: import multiprocessing import sys def worker_with(lock, f):     with lock:         fs = open(f,"a+")         fs.write('Lock acquired via with\n')         fs.close()         def

  • 理解生产者消费者模型及在Python编程中的运用实例

    理解生产者消费者模型及在Python编程中的运用实例

    什么是生产者消费者模型 在 工作中,大家可能会碰到这样一种情况:某个模块负责产生数据,这些数据由另一个模块来负责处理(此处的模块是广义的,可以是类.函数.线程.进程等).产 生数据的模块,就形象地称为生产者:而处理数据的模块,就称为消费者.在生产者与消费者之间在加个缓冲区,我们形象的称之为仓库,生产者负责往仓库了进商 品,而消费者负责从仓库里拿商品,这就构成了生产者消费者模型.结构图如下: 生产者消费者模型的优点: 1.解耦 假设生产者和消费者分别是两个类.如果让生产者直接调用消费者的某个方法,

  • Python多线程同步Lock、RLock、Semaphore、Event实例

    Python多线程同步Lock、RLock、Semaphore、Event实例

    一.多线程同步 由于CPython的python解释器在单线程模式下执行,所以导致python的多线程在很多的时候并不能很好地发挥多核cpu的资源.大部分情况都推荐使用多进程. python的多线程的同步与其他语言基本相同,主要包含: Lock & RLock :用来确保多线程多共享资源的访问. Semaphore : 用来确保一定资源多线程访问时的上限,例如资源池.  Event : 是最简单的线程间通信的方式,一个线程可以发送信号,其他的线程接收到信号后执行操作. 二.实例 1)Lock &a

  • Python之两种模式的生产者消费者模型详解

    第一种使用queue队列实现: #生产者消费者模型 其实服务器集群就是这个模型 # 这里介绍的是非yield方法实现过程 import threading,time import queue q = queue.Queue(maxsize=10) def Producer(anme): # for i in range(10): # q.put('骨头%s'%i) count = 1 while True: q.put('骨头%s'%count) print('生产了骨头',count) cou

  • Python自定义进程池实例分析【生产者、消费者模型问题】

    本文实例分析了Python自定义进程池.分享给大家供大家参考,具体如下: 代码说明一切: #encoding=utf-8 #author: walker #date: 2014-05-21 #function: 自定义进程池遍历目录下文件 from multiprocessing import Process, Queue, Lock import time, os #消费者 class Consumer(Process): def __init__(self, queue, ioLock):

  • Python 限制线程的最大数量的方法(Semaphore)

    如下所示: import threading import time sem=threading.Semaphore(4) #限制线程的最大数量为4个 def gothread(): with sem: #锁定线程的最大数量 for i in range(8): print(threading.current_thread().name,i) time.sleep(1) for i in range(5): threading.Thread(target=gothread).start() 以上

  • python线程信号量semaphore使用解析

    这篇文章主要介绍了python线程信号量semaphore使用解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.semaphore信号量原理 多线程同时运行,能提高程序的运行效率,但是并非线程越多越好,而semaphore信号量可以通过内置计数器来控制同时运行线程的数量,启动线程(消耗信号量)内置计数器会自动减一,线程结束(释放信号量)内置计数器会自动加一:内置计数器为零,启动线程会阻塞,直到有本线程结束或者其他线程结束为止; 二.sem

  • python之生产者消费者模型实现详解

    代码及注释如下 #Auther Bob #--*--conding:utf-8 --*-- #生产者消费者模型,这里的例子是这样的,有一个厨师在做包子,有一个顾客在吃包子,有一个服务员在储存包子,这个服务员我们就可以用queue来实现 import threading import queue import time ''' def consumer(p,que): id = que.get() print("[%s]来吃包子了,我吃到的包子的名字是[%s]" %(p,id)) def

  • Python semaphore evevt生产者消费者模型原理解析

    线程锁相当于同时只能有一个线程申请锁,有的场景无数据修改互斥要求可以同时让多个线程同时运行,且需要限制并发线程数量时可以使用信号量 import threading, time, queue def test(name): semaphore.acquire() #获取信号量锁 print('my name is %s' %name) time.sleep(1) semaphore.release() #释放信号量锁 semaphore = threading.BoundedSemaphore(

  • Java实现简易生产者消费者模型过程解析

    一.概述 一共两个线程,一个线程生产产品,一个线程消费产品,使用同步代码块方法,同步两个线程.当产品没有时,通知生产者生产,生产者生产后,通知消费者消费,并等待消费者消费完. 需要注意的是,有可能出现,停止生产产品后,消费者还没未来得及消费生产者生产的最后一个产品,就结束消费,导致最后一个产品没有被消费. 本例使用synchronize以及wait().notify()实现简易版的线程者消费者模型. 二.测试用例 这里的产品用笔来演示,每只笔都有其编号code 一共有四个类:分别是生产者类,产品

  • python 并发编程 阻塞IO模型原理解析

    python 并发编程 阻塞IO模型原理解析

    阻塞IO(blocking IO) 在linux中,默认情况下所有的socket都是blocking,一个典型的读操作流程大概是这样: 当用户进程调用了recvfrom这个系统调用,kernel内核就开始了IO的第一个阶段:准备数据.对于network io( 网络io )来说,很多时候数据在一开始还没有到达(比如,还没有收到一个完整的UDP包),这个时候kernel( 内核 )就要等待足够的数据到来. 等着对方把数据放到自己操作系统内存 而在用户进程这边,整个进程会被阻塞.当kernel一直等

  • Python教程之生产者消费者模式解析

    Python教程之生产者消费者模式解析

    为什么使用生产者消费者模式 在线程世界里,生产者就是生产数据的线程,消费者就是消费数据的线程.在多线程开发中,如果生产者处理速度很快,而消费者处理速度很慢,那么生产者就必须等待消费者处理完才能继续生产数据.同样的道理,如果消费者的处理能力大于生产者,那么消费者就必须等待生产者.为了解决这个问题引入了生产者和消费者模式. 什么是生产者消费者模式 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题.生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用通

  • Python生成器实现简单"生产者消费者"模型代码实例

    Python生成器实现简单"生产者消费者"模型代码实例

    生成器定义 在Python中,一边循环一边计算的机制,称为生成器:generator. 为什么要有生成器 列表所有数据都在内存中,如果有海量数据的话将会非常耗内存. 如:仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了. 如果列表元素按照某种算法推算出来,那我们就可以在循环的过程中不断推算出后续的元素,这样就不必创建完整的list,从而节省大量的空间. 简单一句话:我又想要得到庞大的数据,又想让它占用空间少,那就用生成器! 使用生成器实现简单的生产者消费者模型 1.效果截屏 代

  • 生产者消费者模型ThreadLocal原理及实例详解

    1.生产者消费者模型作用和示例如下: 1)通过平衡生产者的生产能力和消费者的消费能力来提升整个系统的运行效率 ,这是生产者消费者模型最重要的作用 2)解耦,这是生产者消费者模型附带的作用,解耦意味着生产者和消费者之间的联系少,联系越少越可以独自发展而不需要收到相互的制约 备注:对于生产者消费者模型的理解将在并发队列BlockingQueue章节进行说明,本章不做详细介绍. package threadLearning.productCustomerModel; /* wait/notify 机制

  • 浅谈生产者消费者模型(Linux系统下的两种实现方法)

    浅谈生产者消费者模型(Linux系统下的两种实现方法)

    生产者消费者问题是同步问题中的一种常见情况,借用一下维基百科的话 生产者消费者问题(英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同步问题的经典案例.该问题描述了两个共享固定大小缓冲区的线程--即所谓的"生产者"和"消费者"--在实际运行时会发生的问题.生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程.与此同时,消费者也在缓冲区消耗这些数据.该问题的关键就

随机推荐