#queue队列 #生产者消费者模型

  1 #queue队列  #生产者消费者模型
  2
  3 #queue队列 #有顺序的容器
  4 #程序解耦
  5 #提高运行效率
  6
  7 #class queue.Queue(maxsize=0) #先入先出
  8 #class queue.LifoQueue(maxsize=0)最后在第一
  9 #class queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列#VIP客户
 10
 11 #Queue.qsize()
 12 #Queue.empty() #return True if empty
 13 #Queue.full() # return True if full
 14 #Queue.put(item, block=True, timeout=None)
 15
 16 ‘‘‘
 17 import queue
 18 q = queue.Queue()
 19 q.put(‘d1‘)
 20 q.put(‘d2‘)
 21 q.put(‘d3‘)
 22 print (q.qsize())
 23
 24 print(q.get())
 25 print(q.get())
 26 print(q.get())
 27 print(q.get())#没有东西就卡死了
 28 ‘‘‘
 29 ‘‘‘
 30 import queue
 31
 32 q = queue.Queue()
 33 q.put(1)
 34 q.put(2)
 35 q.put(3)
 36
 37 print(q.get())
 38 print(q.get())
 39 print(q.get())
 40 #print(q.get())#没有东西就卡死了
 41
 42 print(q.qsize())#查看
 43 q.get_nowait()#异常
 44 ‘‘‘
 45 ‘‘‘
 46 #后进先出
 47 import queue
 48 q = queue.LifoQueue()
 49 q.put(1)
 50 q.put(2)
 51 q.put(3)
 52
 53 print(q.get())
 54 print(q.get())
 55 print(q.get())
 56 ‘‘‘
 57 ‘‘‘
 58 #VIP
 59 import queue
 60
 61 q = queue.PriorityQueue()
 62 q.put((-1,‘c‘))
 63 q.put((3,‘h‘))
 64 q.put((10,‘alex‘))
 65 q.put((6,‘w‘))
 66
 67 print(q.get())
 68 print(q.get())
 69 print(q.get())
 70 print(q.get())
 71 ‘‘‘
 72 #生产者消费者模型
 73
 74 import threading,time
 75 import queue
 76
 77 q = queue.Queue(maxsize=10)
 78
 79 def Producer(name):
 80     count =1
 81     while True:
 82         q.put(‘骨头%s‘% count)
 83         print (‘生成了骨头‘,count)
 84         count +=1
 85         time.sleep(0.1)
 86 def Consumer(name):
 87     #while q.qsize() > 0 :
 88     while True:
 89         print (‘[%s] 取到 [%s] 并且吃了它...‘% (name,q.get()))
 90         time.sleep(1)
 91
 92 p = threading.Thread(target=Producer,args=(‘Alex‘,))
 93 c = threading.Thread(target=Consumer,args=(‘陈荣华‘,))
 94 c1 = threading.Thread(target=Consumer,args=(‘王森‘,))
 95 p.start()
 96 c.start()
 97 c1.start()
 98
 99
100
101
102 #下面来学习一个最基本的生产者消费者模型的例子
103 ‘‘‘
104 import threading
105 import queue
106
107 def producer():
108     for i in range(10):
109         q.put("骨头 %s" % i )
110
111     print("开始等待所有的骨头被取走...")
112     q.join()
113     print("所有的骨头被取完了...")
114
115 def consumer(n):
116     while q.qsize() >0:
117         print("%s 取到" %n  , q.get())
118         q.task_done() #告知这个任务执行完了
119
120 q = queue.Queue()
121 p = threading.Thread(target=producer,)
122 p.start()
123 c1 = consumer("李闯")
124 ‘‘‘
125
126
127 ‘‘‘
128 import time,random
129 import queue,threading
130 q = queue.Queue()
131 def Producer(name):
132   count = 0
133   while count <20:
134     time.sleep(random.randrange(3))
135     q.put(count)
136     print(‘Producer %s has produced %s baozi..‘ %(name, count))
137     count +=1
138 def Consumer(name):
139   count = 0
140   while count <20:
141     time.sleep(random.randrange(4))
142     if not q.empty():
143         data = q.get()
144         print(data)
145         print(‘1mConsumer %s has eat %s baozi...‘ %(name, data))
146     else:
147         print("-----no baozi anymore----")
148     count +=1
149 p1 = threading.Thread(target=Producer, args=(‘A‘,))
150 c1 = threading.Thread(target=Consumer, args=(‘B‘,))
151 p1.start()
152 c1.start()
153 ‘‘‘

#queue队列 #生产者消费者模型

时间: 2024-10-09 23:28:12

#queue队列 #生产者消费者模型的相关文章

13 join 线程锁之Lock\Rlock\信号量 将线程变为守护进程 Event事件  queue队列 生产者消费者模型 Queue队列 开发一个线程池

本节内容 操作系统发展史介绍 进程.与线程区别 python GIL全局解释器锁 线程 语法 join 线程锁之Lock\Rlock\信号量 将线程变为守护进程 Event事件 queue队列 生产者消费者模型 Queue队列 开发一个线程池 进程 语法 进程间通讯 进程池 操作系统发展史 手工操作(无操作系统) 1946年第一台计算机诞生--20世纪50年代中期,还未出现操作系统,计算机工作采用手工操作方式. 手工操作程序员将对应于程序和数据的已穿孔的纸带(或卡片)装入输入机,然后启动输入机把

python2.0_s12_day9之day8遗留知识(queue队列&amp;生产者消费者模型)

4.线程 1.语法 2.join 3.线程锁之Lock\Rlock\信号量 4.将线程变为守护进程 5.Event事件 * 6.queue队列 * 7.生产者消费者模型 4.6 queue队列 queue非常有用,当信息必须安全的在多个线程之间进行数据交换的时候就应该想到queue 所以,queue它能保证数据被安全的在多个线程之间进行交换,那他就是天生的线程安全. queue有那么几种: class queue.Queue(maxsize=0) # 先入先出 class queue.LifoQ

Python学习笔记——进阶篇【第九周】———线程、进程、协程篇(队列Queue和生产者消费者模型)

Python之路,进程.线程.协程篇 本节内容 进程.与线程区别 cpu运行原理 python GIL全局解释器锁 线程 语法 join 线程锁之Lock\Rlock\信号量 将线程变为守护进程 Event事件 queue队列 生产者消费者模型 Queue队列 开发一个线程池 进程 语法 进程间通讯 进程池 参考链接http://www.cnblogs.com/alex3714/articles/5230609.html

python并发编程之多进程(二):互斥锁(同步锁)&amp;进程其他属性&amp;进程间通信(queue)&amp;生产者消费者模型

一,互斥锁,同步锁 进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的, 竞争带来的结果就是错乱,如何控制,就是加锁处理 part1:多个进程共享同一打印终端 #并发运行,效率高,但竞争同一打印终端,带来了打印错乱 from multiprocessing import Process import os,time def work(): print('%s is running' %os.getpid()) time.sleep(2) print('

5 并发编程--队列&amp;生产者消费者模型

1.队列的介绍 进程彼此之间互相隔离,要实现进程间通信(IPC),multiprocessing模块支持两种形式:队列和管道,这两种方式都是使用消息传递的 创建队列的类(底层就是以管道和锁定的方式实现): Queue([maxsize]):创建共享的进程队列,Queue是多进程安全的队列,可以使用Queue实现多进程之间的数据传递. 参数介绍: maxsize是队列中允许最大项数,省略则无大小限制. 但需要明确: 1.队列内存放的是消息而非大数据 2.队列占用的是内存空间,因而maxsize即便

Queue 实现生产者消费者模型

Python中,队列是线程间最常用的交换数据的形式. Python Queue模块有三种队列及构造函数: 1.Python Queue模块的FIFO队列先进先出. class Queue.Queue(maxsize) 2.LIFO类似于堆,即先进后出. class Queue.LifoQueue(maxsize) 3.还有一种是优先级队列级别越低越先出来. class Queue.PriorityQueue(maxsize) 此包中的常用方法(q = Queue.Queue()): q.qsiz

生产者消费者模型及队列,进程池

生产者消费者模型 生产者消费者模型 主要是为了解耦 可以借助队列来实现生产者消费者模型 栈 : 先进后出(First In Last Out 简称 FILO) 队列 : 先进先出(First In First Out 简称 FIFO) import queue #不能进行多进程之间的数据传输(1) from multiprocessing import Queue #借助Queue解决生产者消费者模型,队列是安全的q=Queue(num)num : 队列的最大长度q.get() #阻塞等待获取数

进程 &gt;&gt; 互斥锁、队列与管道、生产者消费者模型

目录 1.互斥锁 2.队列与管道 3.生产者消费者模型(Queue) 4.生产者消费者模型(JoinableQueue) 1.互斥锁 首先导入Lock模块 实例化一把锁 但是每次生成子进程的时候都会重新实例化一把锁,我们的目的是想让所有的子进程使用同一把锁,所以需要把锁传递给子进程在使用 锁名.acquire():开锁->所有子进程开始抢位置 锁名.release():关锁->位置排好了,开始执锁起来执行. join与互斥锁的区别:join是把所有的子进程代码变为串行的,而互斥锁则可以规定那几

队列、生产者消费者模型

目录 队列.生产者消费者模型.初识线程 一.用进程锁来优化抢票小程序 1.1 进程锁 1.2 优化抢票小程序 二.队列 2.1 队列的介绍 2.2 创建队列的类 2.3 使用队列的案例 三.生产者消费者模型 3.1 用队列Queue实现生产者消费者模型 3.2 用队列JoinableQueue实现生产者消费者模型 队列.生产者消费者模型.初识线程 一.用进程锁来优化抢票小程序 1.1 进程锁 进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端是没有问题的.而共享带来