目录
进程、线程对比
- 进程,能够完成多任务,比如 在一台电脑上能够同时运行多个QQ
- 线程,能够完成多任务,比如 一个QQ中的多个聊天窗口
- 进程是系统进行资源分配和调度的一个独立单位
- 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位
- 一个程序至少有一个进程,一个进程至少有一个线程
- 线程执行开销小,但不利于资源的管理和保护,而进程正相反
一、进程以及状态
1、进程
- 程序:例如xxx.py这是一个程序,这个是静态的
- 进程:一个程序运行起来以后,代码+用到的资源称之为进程,它是操作系统分配的资源的基本单位
不仅可以通过线程来完成多任务,进程也可以
2、进程的状态
工作中,任务数往往大于CPU的核数,即一定有一些任务正在执行,而另外一些任务在等待CPU进行执行,因此导致了不同的状态
二、进程的创建—multiprocessing
multiprocessing模块就是跨平台版本的多进程模块,提供了一个Process类来代表一个进程对象,这个对象可以理解为是一个独立的进程,可以执行另外的事情
Process([group [, target [, name [, args [, kwargs]]]]])
- target:如果传递了函数的引用,可以任务这个子进程就执行这里的代码
- args:给target指定的函数传递的参数,以元组的方式传递
- kwargs:给target指定的函数传递命名参数
- name:给进程设定一个名字,可以不设定
- group:指定进程组,大多数情况下用不到
Process创建的实例对象的常用方法:
- start():启动子进程实例(创建子进程)
- is_alive():判断进程子进程是否还在活着
- join([timeout]):是否等待子进程执行结束,或等待多少秒
- terminate():不管任务是否完成,立即终止子进程
Process创建的实例对象的常用属性:
- name:当前进程的别名,默认为Process-N,N为从1开始递增的整数
- pid:当前进程的pid(进程号)
1、2个while循环一起执行
创建子进程时,只需要传入一个执行函数和函数的参数,创建一个Process实例,用start()方法启动
from multiprocessing import Process
import time
def run_proc():
'''子进程要执行的代码'''
while True:
print("-----2-----")
time.sleep(1)
if __name__ == "__main__":
p = Process(target=run_proc)
p.start()
while True:
print("-----1-----")
time.sleep(1)
#输出
-----1-----
-----2-----
-----1-----
-----2-----
-----1-----
-----2-----
...
2、进程pid
from multiprocessing import Process
import os
def run_proc():
'''子进程要执行的代码'''
print("子进程运行中,pid=%d ..." % os.getpid())
print("子进程结束...")
if __name__ == "__main__":
print("父进程pid:%d " % os.getpid())
p = Process(target=run_proc)
p.start()
#输出
父进程pid:7700
子进程运行中,pid=11472 ...
子进程结束...
3、给子进程指定的函数传递出参数
from multiprocessing import Process
import time
import os
def run_proc(name,age,**kwargs):
for i in range(5):
print("子进程运行中,name=%s,age=%d,pid=%d ..." % (name,age,os.getpid()))
print(kwargs)
time.sleep(0.2)
if __name__ == "__main__":
p = Process(target=run_proc,args=('test',18),kwargs={"m":20})
p.start()
time.sleep(1)
p.terminate()
p.join()
#输出
子进程运行中,name=test,age=18,pid=6232 ...
{'m': 20}
子进程运行中,name=test,age=18,pid=6232 ...
{'m': 20}
...
4、进程间不同享全局变量
from multiprocessing import Process
import time
import os
nums = [11,12]
def work1():
'''子进程要执行的代码'''
print("in process1 pid=%d,num=%s " % (os.getpid(),nums))
for i in range(2):
nums.append(i)
time.sleep(1)
print("in process1 pid=%d,num=%s" % (os.getpid(),nums))
def work2():
'''子进程要执行的代码'''
for i in range(2):
print("in process2 pid=%d,num=%s" % (os.getpid(),nums))
time.sleep(1)
if __name__ == "__main__":
p1 = Process(target=work1)
p2 = Process(target=work2)
p1.start()
p1.join()
p2.start()
#输出
in process1 pid=11200,num=[11, 12]
in process1 pid=11200,num=[11, 12, 0]
in process1 pid=11200,num=[11, 12, 0, 1]
in process2 pid=13020,num=[11, 12]
in process2 pid=13020,num=[11, 12]
三、进程间通信—Queue
Process之间有时需要通信,操作系统提供了很多机制来实现进程间的通信
1、Queue的使用
可以使用multiprocessing模块的Queue实现多进程之间的数据传递
Queue本身是一个消息列队程序,首先用一个小实例来演示一下Queue的工作原理:
from multiprocessing import Queue
q=Queue(3) #初始化一个Queue对象,最多可接收三条put消息
q.put("消息1")
q.put("消息2")
print(q.full()) #False
#用来判断Queue对象是否已满
q.put("消息3")
print(q.full()) #True
from multiprocessing import Queue
q=Queue(3) #初始化一个Queue对象,最多可接收三条put消息
q.put("消息1")
q.put("消息2")
q.put("消息3")
#因为消息列队已满下面的try都会抛出异常,第一个try会等待2秒后再抛出异常,第二个Try会立刻抛出异常
try:
q.put("消息4",True,2)
except:
print("消息列队已满,现有消息数量:%s"%q.qsize())
try:
q.put_nowait("消息4")
except:
print("消息列队已满,现有消息数量:%s"%q.qsize())
#推荐的方式,先判断消息列队是否已满,再写入
if not q.full():
q.put_nowait("消息4")
#读取消息时,先判断消息列队是否为空,再读取
if not q.empty():
for i in range(q.qsize()):
print(q.get_nowait())
#输出
消息列队已满,现有消息数量:3
消息列队已满,现有消息数量:3
消息1
消息2
消息3
初始化Queue()对象时(例如:q=Queue()),若括号中没有指定最大可接收的消息数量,或数量为负值,那么就代表可接受的消息数量没有上限(直到内存的尽头);
-
Queue.qsize():返回当前队列包含的消息数量;
-
Queue.empty():如果队列为空,返回True,反之False ;
-
Queue.full():如果队列满了,返回True,反之False;
-
Queue.get([block[, timeout]]):获取队列中的一条消息,然后将其从列队中移除,block默认值为True;
- 如果block使用默认值,且没有设置timeout(单位秒),消息列队如果为空,此时程序将被阻塞(停在读取状态),直到从消息列队读到消息为止,如果设置了timeout,则会等待timeout秒,若还没读取到任何消息,则抛出"Queue.Empty"异常;
- 如果block值为False,消息列队如果为空,则会立刻抛出"Queue.Empty"异常;
-
Queue.get_nowait():相当Queue.get(False);
-
Queue.put(item,[block[, timeout]]):将item消息写入队列,block默认值为True;
- 如果block使用默认值,且没有设置timeout(单位秒),消息列队如果已经没有空间可写入,此时程序将被阻塞(停在写入状态),直到从消息列队腾出空间为止,如果设置了timeout,则会等待timeout秒,若还没空间,则抛出"Queue.Full"异常;
- 如果block值为False,消息列队如果没有空间可写入,则会立刻抛出"Queue.Full"异常;
- Queue.put_nowait(item):相当Queue.put(item, False);
2、Queue实例
from multiprocessing import Process,Queue
import os,time,random
#写数据进程执行的代码
def write(q):
for value in ['a','b','c','d']:
print('Put %s to queue ... ' % value)
q.put(value)
time.sleep(random.random())
#读数据进程执行的代码
def read(q):
while True:
if not q.empty():
value = q.get(True)
print('Get %s from queue ... ' % value)
time.sleep(random.random())
else:
break
if __name__ == '__main__':
# 父进程创建Queue,并传给各个子进程:
q = Queue()
pw = Process(target=write, args=(q,))
pr = Process(target=read, args=(q,))
# 启动子进程pw,写入:
pw.start()
# 等待pw结束:
pw.join()
# 启动子进程pr,读取:
pr.start()
pr.join()
# pr进程里是死循环,无法等待其结束,只能强行终止:
print('')
print('所有数据都写入并且读完')
#输出
Put a to queue ...
Put b to queue ...
Put c to queue ...
Put d to queue ...
Get a from queue ...
Get b from queue ...
Get c from queue ...
Get d from queue ...
所有数据都写入并且读完
四、进程池Pool(很多很多进程)
当需要创建的子进程数量不多时,可以直接利用multiprocessing中的Process动态成生多个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法
初始化Pool时,可以指定一个最大进程数
当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求
但如果池中的进程数已经达到指定的最大值,那么该请求就会等待,直到池中有进程结束,才会用之前的进程来执行新的任务
multiprocessing.Pool常用函数解析:
- apply_async(func[, args[, kwds]]) :使用非阻塞方式调用func(并行执行,堵塞方式必须等待上一个进程退出才能执行下一个进程),args为传递给func的参数列表,kwds为传递给func的关键字参数列表;
- close():关闭Pool,使其不再接受新的任务;
- terminate():不管任务是否完成,立即终止;
- join():主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用;
进程池中的Queue
如果要使用Pool创建进程,就需要使用multiprocessing.Manager()中的Queue(),而不是multiprocessing.Queue(),否则会得到一条如下的错误信息:
RuntimeError: Queue objects should only be shared between processes through inheritance.
下面的实例演示了进程池中的进程如何通信:
# 修改import中的Queue为Manager
from multiprocessing import Manager,Pool
import os,time
def reader(q):
print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
for i in range(q.qsize()):
print("reader从Queue获取到消息:%s" % q.get(True))
def writer(q):
print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
for i in "love33":
q.put(i)
if __name__=="__main__":
print("(%s) start" % os.getpid())
q = Manager().Queue() # 使用Manager中的Queue
po = Pool()
po.apply_async(writer, (q,))
time.sleep(1) # 先让上面的任务向Queue存入数据,然后再让下面的任务开始从中取数据
po.apply_async(reader, (q,))
po.close()
po.join()
print("(%s) End" % os.getpid())
#输出
(14724) start
writer启动(5264),父进程为(14724)
reader启动(13088),父进程为(14724)
reader从Queue获取到消息:l
reader从Queue获取到消息:o
reader从Queue获取到消息:v
reader从Queue获取到消息:e
reader从Queue获取到消息:3
reader从Queue获取到消息:3
(14724) End