认识python中的进程
一、程序和进程的区别
编写完毕的代码，在没有运行的时候，称之为程序。
正在运行着的代码，就称为进程。它除了包含代码以外，还有需要运行的环境等，所以它和程序有所区别
二、进程的创建
主要有以下几种方式：
-
- fork()函数----（不支持windows系统）
- 实例化multiprocessing模块中的Process类或其子类(跨平台，适用于子进程数量较少时)
- 进程池（适用于子进程数量较多时）
1.fork（）函数
在Unix/Linux操作系统中，提供了一个fork()系统函数，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。父进程、子进程执行顺序没有规律，完全取决于操作系统的调度算法
示例:
import os # 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以 pid = os.fork() if pid == 0: print('哈哈1') else: print('哈哈2')
2.实例化multiprocessing模块中的Process类或子类
multiprocessing模块就是跨平台版本的多进程模块，提供了一个Process类来代表一个进程对象。创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。
Process语法结构：
Process([group [, target [, name [, args [, kwargs]]]]])
-
-
-
target：表示这个进程实例所调用对象；
-
args：表示调用对象的位置参数元组；
-
kwargs：表示调用对象的关键字参数字典；
-
name：为当前进程实例的别名；
-
group：大多数情况下用不到；
-
-
Process类常用方法：
-
-
-
is_alive()：判断进程实例是否还在执行；
-
join([timeout])：是否等待进程实例执行结束，或等待多少秒；
-
start()：启动进程实例（创建子进程）；
-
run()：如果没有给定target参数，对这个对象调用start()方法时，就将执行对象中的run()方法；
-
terminate()：不管任务是否完成，立即终止；
-
-
Process类常用属性：
-
-
-
name：当前进程实例别名，默认为Process-N，N为从1开始递增的整数；
-
pid：当前进程实例的PID值；
-
-
示例1：Process类创建进程
#coding=utf-8 from multiprocessing import Process import os # 子进程要执行的代码 def run_proc(name): print('子进程运行中，name= %s ,pid=%d...' % (name, os.getpid())) if __name__=='__main__': print('父进程 %d.' % os.getpid()) p = Process(target=run_proc, args=('test',)) print('子进程将要执行') p.start() p.join() print('子进程已结束')
示例2：Process子类创建进程
from multiprocessing import Process import time import os #继承Process类 class Process_Class(Process): def __init__(self,interval): Process.__init__(self) self.interval = interval #重写了Process类的run()方法 def run(self): print("子进程(%s) 开始执行，父进程为（%s）"%(os.getpid(),os.getppid())) t_start = time.time() time.sleep(self.interval) t_stop = time.time() print("(%s)执行结束，耗时%0.2f秒"%(os.getpid(),t_stop-t_start)) if __name__=="__main__": t_start = time.time() print("当前程序进程(%s)"%os.getpid()) p1 = Process_Class(2) #对一个不包含target属性的Process类执行start()方法，就会运行这个类中的run()方法，所以这里会执行p1.run() p1.start() p1.join() t_stop = time.time() print("(%s)执行结束，耗时%0.2f"%(os.getpid(),t_stop-t_start))
3.进程池
当需要创建的子进程数量达到上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束才会执行。需要注意的是，主进程不会主动等待进程池中的所有子进程结束后才结束，需要使用进程池的join()方法来堵塞主进程。
multiprocessing.Pool常用函数解析：
-
-
apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行），args为传递给func的参数元组，kwds为传递给func的关键字参数字典；
-
apply(func[, args[, kwds]])：使用阻塞方式调用func，必须等待上一个进程退出才能执行下一个进程
-
close()：关闭Pool，使其不再接受新的任务，正在执行的任务会继续执行；
-
terminate()：不管任务是否完成，立即终止；
-
join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；
-
示例1(apply_async非阻塞式)：
from multiprocessing import Pool import os,time,random def worker(msg): t_start = time.time() print("%s开始执行,进程号为%d"%(msg,os.getpid())) #random.random()随机生成0~1之间的浮点数 time.sleep(random.random()*2) t_stop = time.time() print(msg,"执行完毕，耗时%0.2f"%(t_stop-t_start)) po=Pool(3) #定义一个进程池，最大进程数3 for i in range(0,10): #以非阻塞的方式向Po中添加任务 po.apply_async(worker,(i,)) print("----start----") po.close() #关闭进程池，关闭后po不再接收新的请求 po.join() #等待po中所有子进程执行完成，必须放在close语句之后 print("-----end-----")
运行结果:
----start---- 0开始执行,进程号为28768 1开始执行,进程号为28769 2开始执行,进程号为28767 1 执行完毕，耗时0.66 3开始执行,进程号为28769 2 执行完毕，耗时1.35 4开始执行,进程号为28767 0 执行完毕，耗时1.49 5开始执行,进程号为28768 4 执行完毕，耗时0.15 5 执行完毕，耗时0.65 3 执行完毕，耗时1.76 -----end-----
示例2：（map非阻塞式：更简单）
from multiprocessing import Pool import os,time,random def worker(msg): t_start = time.time() print("%s开始执行,进程号为%d"%(msg,os.getpid())) #random.random()随机生成0~1之间的浮点数 time.sleep(random.random()*2) t_stop = time.time() print(msg,"执行完毕，耗时%0.2f"%(t_stop-t_start)) if __name__ == '__main__': po=Pool(3) #定义一个进程池，最大进程数3 # map # 第一个参数是目标函数，第二个参数是包含参数的容器（可迭代对象），返回值：包含所有执行结果的一个列表 # 不需要执行join操作，内部已经封装好 po.map(worker, range(10)) print("-----end-----")
示例2：(apply阻塞式)
from multiprocessing import Pool import os,time,random def worker(msg): t_start = time.time() print("%s开始执行,进程号为%d"%(msg,os.getpid())) #random.random()随机生成0~1之间的浮点数 time.sleep(random.random()*2) t_stop = time.time() print(msg,"执行完毕，耗时%0.2f"%(t_stop-t_start)) po=Pool(3) #定义一个进程池，最大进程数3 for i in range(6): #以阻塞的方式向Po中添加任务 po.apply(worker,(i,)) print("----start----") po.close() #关闭进程池，关闭后po不再接收新的请求 print("-----end-----")
运行结果：
0开始执行,进程号为28782 0 执行完毕，耗时0.93 1开始执行,进程号为28781 1 执行完毕，耗时1.25 2开始执行,进程号为28783 2 执行完毕，耗时0.53 3开始执行,进程号为28782 3 执行完毕，耗时0.27 4开始执行,进程号为28781 4 执行完毕，耗时0.93 5开始执行,进程号为28783 5 执行完毕，耗时1.69 ----start---- -----end-----
三、进程间通信-Queue
进程间是不共享数据（包括全局变量）的，但是可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序(先进先出)。初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）。如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，否则就会抛出异常。
Queue()对象常用方法:
-
- qsize()：返回当前队列包含的消息数量；
- empty()：如果队列为空，返回True，反之False ；
- full()：如果队列满了，返回True,反之False；
- get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；
- 如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；
- 如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；
- get_nowait()：消息列队如果为空，则会立刻抛出"Queue.Empty"异常，相当于get(False)；
- put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；
- 如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常；
- 如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；
- put_nowait()：消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常，相当于put(False)
示例1：
# coding:utf-8 from multiprocessing import Queue q = Queue(3) #创建一个消息队列，能容纳3条消息 q.put('A') q.put('B') print(q.full()) #返回False q.put('C') print(q.full()) #返回True try: q.put('D',timeout=2) #堵塞等待2秒，后抛出异常 except: print('消息队列已满，现有消息数量%d'%q.qsize()) print(q.get()) #返回A，先进先出 # 在写入消息的时候，先判断队列是否已满 if not q.full(): q.put('D') print("还可以写入消息D") # 在取消息的时候，先判断队列是否为空 if not q.empty(): for i in range(q.qsize()): print(q.get())
示例2：在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据
# coding:utf-8 from multiprocessing import Process,Queue def worker_write(q): '''负责写入''' if not q.full(): for i in range(10): q.put(i) print("写入数据%s"%i) def worker_read(q): '''负责读取''' if not q.empty(): for i in range(q.qsize()): print("读取数据%s"%q.get()) def main(): q = Queue() #创建消息队列 p1 = Process(target=worker_write,args=(q,)) p2 = Process(target=worker_read,args=(q,)) p1.start() #开启写入子进程 p1.join() #等待写入子进程执行完毕 p2.start() #开启读取子进程 p2.join() #等待读取子进程执行完毕 print('所有数据都已写入并读取完毕') if __name__ == '__main__': main()
示例3：进程池中使用Queue
# coding:utf-8 from multiprocessing import Pool,Manager def worker_write(q): '''负责写入''' if not q.full(): for i in range(10): q.put(i) print("写入数据%s"%i) def worker_read(q): '''负责读取''' if not q.empty(): for i in range(q.qsize()): print("读取数据%s"%q.get()) def main(): q = Manager().Queue() #创建消息队列 po = Pool() po.apply(worker_write,args=(q,))# 使用堵塞的方式向Pool中添加任务 po.apply(worker_read,args=(q,)) po.close() print('写入数据并读取数据完毕') if __name__ == '__main__': main()
