一、基本概念
1.1 进程
其实进程就是正在进行的一个程序或者任务，而负责执行任务的是CPU，执行任务的地方是内存。跟程序相比，程序仅仅是一堆代码而已，而程序运行时的过程才是进程。另外同一个程序执行两次就是两个进程了。
1.2 并发与并行
无论是并行还是并发，在用户看来都是‘同时‘运行的，不管是进程还是线程，都只是一个任务而已，真是干活的是cpu，cpu来做这些任务，而一个cpu同一时刻只能执行一个任务。对于“并发”而言，是伪并行，即看起来是同时运行，单个cpu+多道技术就可以实现并发；而“并行”才是真正意义上的“同时运行”——仅有多核才能够实现“并行”。
需要强调的一点是：与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
二、Multiprocessing模块
python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源（os.cpu\_count\(\)查看），在python中大部分情况需要使用多进程。
Python提供了multiprocessing。 multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，>提供了Process、Queue、Pipe、Lock等组件。
2.1 开启子进程的两种方式
2.1.1 直接在Multiprocessing模块中导入Process类，利用这个类实例化进程对象
# -*- coding: utf-8 -*-
# -*- Author: WangHW -*-
#方式一
from multiprocessing import Process
import time
import os
def task(name):
print(‘%s is running...‘%name)
print(‘子进程的id为:‘,os.getpid())
print(‘子进程的父进程的id为:‘,os.getppid())
time.sleep(3)
print(‘%s is done‘%name)
if __name__ == ‘__main__‘:
#Process(target=task, kwargs={‘name‘:‘子进程1‘})
#得到一个对象
p = Process(target=task,args=(‘子进程1‘,))
#start仅仅只是给操作系统发送了一个信号，发完信号以后父进程不会等子进程
#是完全独立的两个进程
p.start()
print(‘主进程‘)
print(‘主进程的id为:‘,os.getpid())
print(‘主进程的父进程id为:‘,os.getppid())
2.2.2 利用类的继承，自己定义一个MyProcessing类，继承自Process，但是需要注意的是：里面必须要有一个名为run的方法去执行主体：
# -*- coding: utf-8 -*-
# -*- Author: WangHW -*-
from multiprocessing import Process
import time
#用类的继承方式实现
class MyProcessing(Process):
def __init__(self,name):
super().__init__()
self.name = name
#注意名字必须叫run
def run(self):
print(‘%s is running......‘%self.name)
time.sleep(3)
print(‘%s is done...‘%self.name)
if __name__ == ‘__main__‘:
p = MyProcessing(‘进程1‘)
p.start()
print(‘主进程‘)
2.2 Process类实例化出对象的join方法
在主进程运行过程中如果想并发地执行其他的任务，我们可以开启子进程，此时主进程的任务与子进程的任务分两种情况
情况一：在主进程的任务与子进程的任务彼此独立的情况下，主进程的任务先执行完毕后，主进程还需要等待子进程执行完毕，然后统一回收资源。
情况二：如果主进程的任务在执行到某一个阶段时，需要等待子进程执行完毕后才能继续执行，就需要有一种机制能够让主进程检测子进程是否运行完毕，在子进程执行完毕后才继续执行，否则一直在原地阻塞，这就是join方法的作用
# -*- coding: utf-8 -*-
# -*- Author: WangHW -*-
from multiprocessing import Process
import time
import os
def task(name,n):
print(‘%s is running...‘%name)
time.sleep(n)
print(‘%s is done...‘% name)
if __name__ == ‘__main__‘:
start_time = time.time()
# for i in range(5,8):
# p = Process(target=task,args=(‘p%s‘%(i+1),i))
# p.start()
#p.join()
p1 = Process(target=task,args=(‘p1‘,5))
p2 = Process(target=task,args=(‘p2‘,2))
p3 = Process(target=task,args=(‘p3‘,3))
#start仅仅是向操作系统发出信号，具体谁先执行不一定，由操作系统决定
p1.start()
p2.start()
p3.start()
#保证有序,看着像“串行”，但实际上还是并行:最后一行的运行时间可以验证
p1.join()
p2.join()
p3.join()
print(‘主进程开启，id为:‘,os.getpid())
#打印出来的结果可知，程序仍然是并发执行的，不是串行执行的
print(‘运行时间:‘,time.time()-start_time)
关于join方法，需要注意的一点是：虽然我们看着像“串行”，但实际上还是并行:由上面程序最后一行的运行时间可以验证：
三、互斥锁
3.1 虽然进程之间数据不共享,但是可以共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争，竞争带来的结果就是错乱。
如何控制，就是加锁处理。而互斥锁的意思就是互相排斥，如果把多个进程比喻为多个人，互斥锁的工作原理就是多个人都要去争抢同一个资源：卫生间，一个人抢到卫生间后上一把锁，其他人都要等着，等到这个完成任务后释放锁，其他人才有可能有一个抢到......所以互斥锁的原理，就是把并发改成穿行，降低了效率，但保证了数据安全不错乱。
这里有一个利用互斥锁模拟抢票的程序（whw.json文件的内容为：{"count": 2}）：
# -*- coding: utf-8 -*-
# -*- Author: WangHW -*-
from multiprocessing import Process,Lock
import json
import time
#查票
def search(name):
time.sleep(1)
with open(‘whw.json‘,‘r‘) as f:
ticket_dict = json.load(f)
print(‘<%s>查看到余票为:<%s>‘%(name,ticket_dict[‘count‘]))
#买票
def get(name):
time.sleep(1)
f = open(‘whw.json‘,‘r‘)
ticket_dict = json.load(f)
print(‘<%s>查看到余票还剩余:<%s>‘%(name,ticket_dict[‘count‘]))
if ticket_dict[‘count‘] > 0:
ticket_dict[‘count‘] -= 1
print(‘<%s>购票成功！‘ % name)
time.sleep(1)
else:
print(‘余票不足~购票失败‘)
f.close()
#保存
f_new = open(‘whw.json‘,‘w‘)
json.dump(ticket_dict,f_new)
f_new.close()
def task(name,mutex):
search(name)
#在购票前加锁
mutex.acquire()
get(name)
#释放锁
mutex.release()
if __name__ == ‘__main__‘:
mutex = Lock()
for i in range(5):
p = Process(target=task,args=(‘路人%s‘%(i+1),mutex))
p.start()
结果展示：
3.2关于互斥锁与join的区别：
用一句话来简单概括：“互斥锁”是将代码的“局部变成串行”，而如果用join的话会整个功能代码变为串行，所以对于本例而言互斥锁要灵活一些。
四、队列
4.1对于多进程有一个问题需要我们考虑：是否有一种方案能够同时兼顾一下两点：一是效率高（多个进程共享一块内存数据），另外一点是能够帮我们处理好锁的问题。
答案就是~~利用队列！
首先，队列是将数据存到内存中处理，这就满足了“效率高”这个要求，另外，队列是基于“管道+锁”设计的，所以另外一点也满足了。事实上，队列才是进程间通信（IPC）的最佳选择！
另外需要大家注意的是：队列是一种先进先出的数据结构。
创建队列用以下方式：
# -*- coding: utf-8 -*-
# -*- Author: WangHW -*-
from multiprocessing import Queue
#队列中不应该放大文件，发的只是精简的消息
#可以不指定大小，但最终受限于内存的大小
q = Queue(3)
q.put(‘hello‘)
q.put({‘a‘:1})
q.put(3333333)
#判断一下队列满没有
print(q.full())
#取出来~先进先出
print(q.get())
print(q.get())
print(q.get())
4.2 队列的应用——生产者消费者模型
“生产者消费者模型”是并发编程的非常重要的一个模型，也是队列的一个非常重要的应用之一：
上图是一个简单的生产者与消费者模型：生产者将生产的DATA先放到队列里，消费者从队列中获取生产者生产的数据，这样使得程序的耦合性大大降低，而且也平衡了生产者与消费者之间的速度差：
具体代码如下：
# -*- coding: utf-8 -*-
# -*- Author: WangHW -*-
from multiprocessing import Process,Queue
import time
def producer(q):
for i in range(5):
res = ‘包子%s‘%i
time.sleep(0.5)
print(‘生产者生产了%s‘%res)
q.put(res)
def consumer(q):
while 1:
res = q.get()
if res is None:
break
time.sleep(1)
print(‘消费者吃了%s‘%res)
if __name__ == ‘__main__‘:
q = Queue()
p1 = Process(target=producer,args=(q,))
p2 = Process(target=producer,args=(q,))
c1 = Process(target=consumer,args=(q,))
c2 = Process(target=consumer,args=(q,))
p1.start()
p2.start()
c1.start()
c2.start()
p1.join()
p2.join()
#有两个消费者，需要最后put两次None
q.put(None)
q.put(None)
#print(‘主进程‘.center(20,‘*‘))
实现效果如下：
当然上面的代码可以利用“守护进程”优化一下（作为了解），将消费者进程设置为守护进程，随着主程序进程一起消除：
# -*- coding: utf-8 -*-
# -*- Author: WangHW -*-
from multiprocessing import Process,JoinableQueue
import time
def producer(q):
for i in range(5):
res = ‘包子%s‘%i
time.sleep(0.5)
print(‘生产者生产了%s‘%res)
q.put(res)
q.join()
def consumer(q):
while 1:
res = q.get()
if res is None:
break
time.sleep(1)
print(‘消费者吃了%s‘%res)
q.task_done()
if __name__ == ‘__main__‘:
q = JoinableQueue()
p1 = Process(target=producer,args=(q,))
p2 = Process(target=producer,args=(q,))
c1 = Process(target=consumer,args=(q,))
c2 = Process(target=consumer,args=(q,))
#将消费者进程设置为守护进程，随着主程序一起消除
c1.daemon = True
c2.daemon = True
p1.start()
p2.start()
c1.start()
c2.start()
p1.join()
p2.join()
五、其他补充
5.1 需要注意的一点是：进程之间的内存空间是相互隔离的，看如下程序：
from multiprocessing import Process
n = 100
def work():
global n
n = 0
print(‘子进程内的n为:‘,n)
if __name__ == ‘__main__‘:
p = Process(target=work)
p.start()
print(‘主进程的n为:‘,n)
运行结果为：
原文地址：https://www.cnblogs.com/paulwhw/p/9108667.html