队列和进程（九）

一、队列

Python的Queue模块中提供了同步的、线程安全的队列类，包括：FIFO（先入先出）队列Queue LIFO(后入先出）队列LifoQueue，优先级队列PriorityQueue，这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。
初始化Queue()对象时（例如：q=Queue(),若括号中没有指定最大接收的消息数量，或者数量为负值，那么代表可接收的消息没有上限）
队列的方法：

def put(self, item, block=True, timeout=None):...
"""往队列传入数据
def get(self, block=True, timeout=None):... 
"""获取队列数据
def put_nowait(self, item):... 
"""往队列传入数据不等待"
def get_nowait(self):...
"""从队列获取数据不等待"""1.

1.先入先出队列

from queue import Queue,LifoQueue,PriorityQueue
q1 = Queue(5)
#往队列添加元素

q1.put(11)
q1.put(12)
q1.put(13)
q1.put(14)
q1.put(15)
print('----5---')
q1.put(22,block=False)#block设为False，就和put_nowait()方法一样
q1.put(11, timeout=3)#如果队列满了，默认会一直等待，通过timeout可以设置等待时间
print('---6---')

#从队列获取元素
print(q1.get())
print(q1.get())
print(q1.get())
print(q1.get())
print(q1.get())
print('---get-5---')
print(q1.get(block=False))#get获取队列中的数据，默认一直等待，block设为False,就和get_nowait方法一样
print('---get-6---')


def qsize(self):...

"""
返回当前队列有多少元素
"""

def empty(self):.... 
"""如果队列为空返回True,反之返回False"

def full(self):...

"""如果队列满了返回True,反之返回False"

def task_done(self):...
"""像队列发送一个信号，表示该任务执行完毕"""

def  join(self):...
"""等待队列所有方法执行完后才往下执行"""
注意点：join()是判断的依据，不单单指的是队列中没有数据，数据get出去后，要使用task_done()向队列发送一个信号，表示该任务执行完毕。
例2：

from threading import Thread
from queue import Queue
number = 0
q = Queue(2)
q.put(number)
def work1():
    for i in range(1000000):
        number = q.get()
        number += 1
        q.put(number)

def work2():
    for i in range(1000000):
        number = q.get()
        number +=1
        q.put(number)
    print(q.get())

def main():
    t1 = Thread(target=work1)
    t2 = Thread(target=work2)
    t1.start()
    t2.start()
main()

执行结果发现使用队列运行速度比线程锁慢，队列处理数据（插入数据，读取数据需要时间）。

2.后入先出队列

3.优先级队列

添加数据的时候可指定优先级

例：

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())
print(pq.get())
print(pq.get())
print(pq.get())

执行结果：

二、进程

1、什么是进程？

程序:pycharm、 QQ都是程序

进程：一个程序运行起来后，代码+用到的资源称之为进程，它是操作系统分配资源的基本单元。

不仅多线程可完成任务，多进程也可以。

2、进程的状态

工作中，任务数往往大于CPU的核数，即一定有一些任务在执行，而另外一些任务在等待CPU进行执行，因此导致了有了不同的状态。

就绪状态：运行的条件已经都满足了，正在等待CPU执行

执行状态：CPU正在执行其功能

等待状态：等待某些条件满足，例如一个程序sleep,此时就处于等待状态

3、进程与线程对比

功能

进程：能够完成多任务，比如，在一个电脑上能够同时运行多个软件

线程，能够完成多个任务，比如一个QQ中的多个聊天窗口

定义的不同

进程是系统进行资源分配和调度的一个独立单位

线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能够独立运行基本单位。线程自己基本是哪个不拥有系统资源，只拥有一点在运行中必不可少的的资源（如程序计数器，一组寄存器和栈），但是它可与同属于一个进程的其他的线程共享进程拥有的全部资源。

区别

一个程序至少有一个进程，一个进程至少有一个线程

线程的划分尺度小于进程（资源比进程少），是使得多线程程序的并发性高

进程在执行过程中拥有独立的内存单元，而多线程共享内存，从而极大地提高了程序的运行效率。

线程不够独立，必须依存在进程中

可以将进程理解为工厂中的一条流水线，而其中的线程就是这个流水上的工人。

优缺点：

线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。

4、multiprocessing

Process（[group[,target[,name[,args,[,kwargs]]]]])

　　target:如果传递了函数的引用，可以任务这个进程就执行这里的代码

　　args:给target指定的函数传递参数，以元组的方式传递

　　kwargs:给target指定的函数传递命名参数

　　name:给进程设定一个名字，可以不设定

　　group:指定进程组，大多数情况下用不到

Process创建的实例对象的常用属性

　　start():启动子进程实例（创建子进程）

　　is_live():判断进程子进程是否还在活着

　　join(timeout):是否等待子进程执行结束，活着等待多少秒

　　terminate():不管任务是否完成，立即终止子进程

Process创建的实例对象常用属性

　　name:当前进程的别名，默认Process-N,N从1开始递增的整数

　　pid:当前进程的pid（进程号）

　　multiprocessing模块就是跨平台版本的对进程模块，提供了一个Process类来代表一个进程对象，这个对象可以理解为是一个独立的进程，可以执行另外的事情。

from multiprocessing import Process
import time
class MyProcess(Process):
  def __init__(self):
    super().__init__()
    
  def run(self):
    with open('text.txt', 'a', encoding='utf8') as f:
      for i in range(2):
        time.sleep(0.5)
        print(F'{self.name} pid:{self.pid} 正在第{i}写入')
        #os.getpid()获取当前进程的进程号
        f.write('python')
      
    
if __name__ == '__main__':
  ps = []
  for i in range(2):
    m = MyProcess()
    m.start()
    ps.append(m)
  ps[0].terminate()

5、进程间通信

使用队列

from multiprocessing import Process, Queue
q = Queue()
for i in range(5):
  q.put(i)
  
def work1(q):
  while not q.empty():
    print('---work1获取数据{}'.format(q.get()))
    
def work2(q):
  while not q.empty():
    print('---work1获取数据{}'.format(q.get()))
    
    
if __name__ == '__main__':
  p1 = Process(target=work1, args=(q,))
  p2 = Process(target=work2, args=(q,))
  p1.start()
  p2.start()

区别：
模块中的队列只能用于一个进程中，各个线程之间通信
进程模块中的Queue可以用于多个进程之间进行通信，使用的时候要用参数进行传递到各个进程任务之中

进程间全局变量不共享

posted @ 2019-08-26 13:58 sinder2018 阅读(28) 评论(0) 收藏举报

刷新页面返回顶部