测试开发进阶(九)
队列
Queue模块中提供了同步的，线程安全的队列类，包括：
- FIFO Queue 先入先出
- LIFO Queue 后入先出
- Priority Queue：优先级队列
这些都实现了 锁原语，能够在多线程中直接使用
from queue import Queue, LifoQueue, PriorityQueue
- Queue:先入先出
- LifoQueue:后入先出
- PriorityQueue:优先级队列
from queue import Queue
q1 = Queue(maxsize=5) # If maxsize is <= 0, the queue size is infinite.
# 往队列中添加元素
q1.put(1)
q1.put(2)
q1.put(3)
q1.put(4)
q1.put(5)
print('-----5-----')
# 数据填满后会等待，可以指定timeout参数
# def put(self, item, block=True, timeout=None)
q1.put(6, timeout=3)
"""
Traceback (most recent call last):
File "/Users/zhongxin/Desktop/py/zx/09/0823.py", line 21, in <module>
q1.put(6, timeout=3)
File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/queue.py", line 147, in put
raise Full
queue.Full
"""
查看put_nowait代码，其实就是put方法的block设置为False
q1.put(22, block=False) # block设为False，就和put_nowait效果一致
def put_nowait(self, item):
'''Put an item into the queue without blocking.
Only enqueue the item if a free slot is immediately available.
Otherwise raise the Full exception.
'''
return self.put(item, block=False)
from queue import Queue
q1 = Queue(maxsize=5) # If maxsize is <= 0, the queue size is infinite.
# 往队列中添加元素
q1.put(1)
q1.put(2)
q1.put(3)
q1.put(4)
q1.put(5)
print('-----5-----')
# 从队列中获取元素
print(q1.get())
print(q1.get())
print(q1.get())
print(q1.get())
print(q1.get())
print('-----5-----')
print(q1.get(block=False))
"""
Traceback (most recent call last):
File "/Users/zhongxin/Desktop/py/zx/09/0823_1.py", line 26, in <module>
print(q1.get(block=False))
File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/queue.py", line 167, in get
raise Empty
_queue.Empty
"""
应用
from threading import Thread
from queue import Queue
num = 0
q = Queue(2)
q.put(num) # 把数据存储在队列中
def work1():
for i in range(1000000):
num = q.get()
num += 1
q.put(num)
def work2():
for i in range(1000000):
num = q.get()
num += 1
q.put(num)
def main():
t1 = Thread(target=work1)
t2 = Thread(target=work2)
t1.start()
t2.start()
t1.join()
t2.join()
print(q.get())
if __name__ == '__main__':
main()
几种get和put
- Queue
# Put a new item in the queue
def _put(self, item):
self.queue.append(item)
# Get an item from the queue
def _get(self):
return self.queue.popleft()
- PriorityQueue
def _put(self, item):
heappush(self.queue, item)
def _get(self):
return heappop(self.queue)
- LifoQueue
def _put(self, item):
self.queue.append(item)
def _get(self):
return self.queue.pop()
优先级队列
from queue import PriorityQueue # 优先级队列
pq = PriorityQueue()
pq.put((1, 11))
pq.put((2, 22))
pq.put((0, 33))
pq.put((99, 333))
# 前面的值越小 越先出来
print(pq.get()) # (0, 33)
print(pq.get()) # (1, 11)
print(pq.get()) # (2, 22)
print(pq.get()) # (99, 333)
进程
进程：操作系统分配资源的基本单元
进程的状态：
- 就绪：准备完全，等待cpu
- 阻塞：等待某些条件满足，例如一个程序sleep了，此时就处于等待状态
- 运行：cpu正在执行其功能
进程，线程对比
功能
- 进程，能够完成多任务，比如 在一台电脑上能同时运行多个软件
- 线程，能够完成多任务，比如一个QQ中的多个聊天窗口
定义
- 进程是系统进行资源分配和调度的一个独立单位
- 线程是进程的一个实体，是CPU调度和分配的基本单位，它是比进程更小的能独立的基本单位，线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈），但是它可与同属一个进程的其他线程共享所拥有的全部资源
区别
- 一个程序至少有一个进程，一个进程至少有一个线程
- 线程的划分尺度小于进程（资源比进程少），使得多线程程序并发性高
- 进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
- 线程不能够独立执行，必须依存在进程中
- 可以将进程理解为工厂中的一条流水线，而线程就是流水线上的工人
优缺点
- 线程执行开销小，但不利于资源的管理和保护；进程正相反
import time
from multiprocessing import Process
def work1():
for i in range(6):
time.sleep(1)
print('执行浇花任务中...')
if __name__ == '__main__':
# 使用多进程来执行多任务
p1 = Process(target=work1)
p1.start()
import time
from multiprocessing import Process
class MyProcess(Process):
def __init__(self, msg):
super().__init__()
self.msg = msg
def run(self):
with open('text.txt', 'a', encoding='utf8') as f:
for i in range(2):
time.sleep(0.5)
f.write(f'{self.msg}\n')
if __name__ == '__main__':
for i in range(2):
MyProcess('python').start()
本文参与 腾讯云自媒体分享计划，分享自微信公众号。
原始发表：2019-08-23，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读