测试开发进阶(九)

队列

Queue模块中提供了同步的，线程安全的队列类，包括：

FIFO Queue 先入先出
LIFO Queue 后入先出
Priority Queue：优先级队列

这些都实现了锁原语，能够在多线程中直接使用

1	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()