一、程序和进程的区别
编写完毕的代码，在没有运行的时候，称之为程序。
正在运行着的代码，就称为进程。它除了包含代码以外，还有需要运行的环境等，所以它和程序有所区别
二、进程的创建
主要有以下几种方式：
- 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：(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()
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
