一、multiprocessing模块介绍
python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源（os.cpu\_count\(\)查看），在python中大部分情况需要使用多进程。Python提供了multiprocessing。
multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。
multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，>提供了Process、Queue、Pipe、Lock等组件。
需要再次强调的一点是：与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
二、Process类的介绍
1，创建进程的类：
"""
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，可用来开启一个子进程
强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
"""2，参数介绍：
# group 参数未使用，值始终为None
# target 表示调用对象，即子进程要执行的任务
# args 表示调用对象的位置参数元组，args=(1,2,'egon',)
# kwargs 表示调用对象的字典,kwargs={'name':'egon','age':18}
# name 为子进程的名称3，方法介绍：
# p.start()：启动进程，并调用该子进程中的p.run()
# p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
# p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
# p.is_alive():如果p仍然运行，返回True
# p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程4，属性介绍：
# p.daemon:默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
# p.name:进程的名称
# p.pid:进程的pid
# p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
# p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
三、Process类的使用
注意：在windows中Process()必须放到 # if __name__ == '__main__':下
"""
Since Windows has no fork, the multiprocessing module starts a new Python process and imports the calling module.
If Process() gets called upon import, then this sets off an infinite succession of new processes (or until your machine runs out of resources).
This is the reason for hiding calls to Process() inside
if __name__ == "__main__"
since statements inside this if-statement will not get called upon import.
由于Windows没有fork，多处理模块启动一个新的Python进程并导入调用模块。
如果在导入时调用Process（），那么这将启动无限继承的新进程（或直到机器耗尽资源）。
这是隐藏对Process（）内部调用的原，使用if __name__ == “__main __”，这个if语句中的语句将不会在导入时被调用。
"""详解
1，创建并开启子进程的两种方式：
# 需要掌握的是，我在启动的这个进程里面，通过某种方式，再开一个子进程，帮我们把这个进程里面的某一个任务并发的去执行一下。
# 这就是我们要掌握的一种方式，借助 multiprocessing 模块,
# Process 这个类可以帮我们得到一个对象，这个对象可以发起：开启子进程的系统调用
# 开启子进程的目的是为了执行一个任务，或者说，执行一个功能。
# 方式一：
from multiprocessing import Process
import time
def task(name):
print("%s is running." % name)
time.sleep(3)
print("%s is done." % name)
if __name__ == "__main__": # windows 系统要把开启进程的指令放在这个下面， linux无所谓
# Process(target=task,kwargs={"name":"子进程1"}) # 两种传参方式，用哪个都行
p = Process(target=task,args=("子进程1",)) # 调 Process 这个类进行实例化，开启进程的目的就是为了去执行一个任务
p.start() # 应用程序开不了子进程，它是给操作系统发了个信号，让操作系统开子进程
print("主")
"""
主
子进程1 is running.
子进程1 is done.
p.start()，只是给操作系统发送一个信号，告诉操作系统，你给我开一个子进程吧，
然后操作系统申请内存空间，把父进程地址空间里边的数据拷贝给子进程，作为子进程运行的初始状态，
开启起来之后，再去运行子进程里面的 task 功能
"""方式一
# 方式二：
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self,name):
super().__init__()
self.name = name
def run(self): # 固定的写 run
print("%s is running." % self.name)
time.sleep(3)
print("%s is done." % self.name)
if __name__ == "main":
p = MyProcess("子进程1")
p.start() # 调用的就是对象下面的绑定方法 run
print("主")
"""
主
子进程1 is running.
子进程1 is done.
"""方式二
2，进程直接的内存空间是隔离的
from multiprocessing import Process
n = 100 # 在windows系统中应该把全局变量定义在if __name__ == '__main__'之上就可以了
def work():
global n
n = 0
print('子进程内: ',n)
if __name__ == '__main__':
p = Process(target=work)
p.start()
print('主进程内: ',n)
# 主进程内: 100
# 子进程内: 0View Code
四、Process 对象的 join 方法
在主进程运行过程中如果想并发地执行其他的任务，我们可以开启子进程，此时主进程的任务与子进程的任务分两种情况
情况一：在主进程的任务与子进程的任务彼此独立的情况下，主进程的任务先执行完毕后，主进程还需要等待子进程执行完毕，然后统一回收资源。
情况二：如果主进程的任务在执行到某一个阶段时，需要等待子进程执行完毕后才能继续执行，就需要有一种机制能够让主进程检测子进程是否运行完毕，在子进程执行完毕后才继续执行，否则一直在原地阻塞，这就是join方法的作用。
# join方法：
# 需求：以前都是主进程先执行完，然后等子进程执行，子进程执行完后把它回收了，
# 新需求：主进程必须等子进程执行完毕后才能执行，必须基于子进程运行完毕后的结果，才能继续运行。
# 这就需要一种机制，能够让主进程一直等着子进程运行结束，这种机制就是，把一个进程开启以后（p.join()）,主进程在那等
from multiprocessing import Process
import time,os
def task():
print("%s is running,parent id is <%s>." % (os.getpid(),os.getppid())) # 通过这个方式就知道那个进程正在进行
time.sleep(3)
print("%s is done,parent id is <%s>." % (os.getpid(),os.getppid())) # 看它自己的进程编号,和它父进程的 id
if __name__ == "__main__":
p = Process(target=task,)
p.start()
p.join() # 主进程卡在这一行，需要等子进程运行完毕，才能运行主进程
print("主", os.getpid(), os.getppid())
print(p.pid) # 在子进程结束掉以后，查看它的pid，就是僵尸进程，不会把它的资源立马回收掉，会保留它的状态信息。
# p.pid 和 os.getpid() 一样都是获得id，主进程结束了，就没有了，状态信息也没有了。
"""
25872 is running,parent id is <3496>.
25872 is done,parent id is <3496>.
主 3496 10776
25872
"""join方法
from multiprocessing import Process
import time
def task(name,n):
print("%s is running." % name)
time.sleep(n)
if __name__ == "__main__":
start = time.time()
p1 = Process(target=task, args=("子进程1", 5))
p2 = Process(target=task, args=("子进程2", 3))
p3 = Process(target=task, args=("子进程3", 2))
p_lis = [p1,p2,p3]
# 它这个不是先开p1，再开p2，再p3，它只是向操作系统发信号，操作系统什么时候开，开多长时间你是控制不了的。
# p1.start()
# p2.start()
# p3.start()
# 它是让主进程等，不是串行的
# p1.join()
# p2.join()
# p3.join()
for p in p_lis:
p.start()
for p in p_lis:
p.join()
print("主", time.time()-start) # 主进程等的就是最长的子进程的时间
# 这个不是串行执行，如果是串行的话，应该是10s
"""
子进程1 is running.
子进程2 is running.
子进程3 is running.
主 5.151699542999268
"""join虽然是等待，但不是串行的，要分清是谁等
# 串行执行
from multiprocessing import Process
import time,os
def task(name,n):
print("%s is running." % name)
time.sleep(n)
if __name__ == "__main__":
start = time.time()
p1 = Process(target=task, args=("子进程1", 5))
p2 = Process(target=task, args=("子进程2", 3))
p3 = Process(target=task, args=("子进程3", 2))
# 这么写就是串行的了，因为p1.start(),之后，join就在原地等着p1，p2的信号压根就发不出去，一个个执行。
p1.start()
p1.join()
p2.start()
p2.join()
p3.start()
p3.join()
print("主", time.time()-start)
"""
子进程1 is running.
子进程2 is running.
子进程3 is running.
主 10.450440645217896
"""串行执行
详解如下：
进程只要 start 就会在开始运行了，所以 p1-p3.start() 时，系统中已经有四个并发的进程了。
而我们 p1.join() 是在等 p1 结束，没错 p1 只要不结束主线程就会一直卡在原地，这也是问题的关键。
join 是让主线程等，而 p1-p3 仍然是并发执行的，p1.join 的时候，其余 p2、p3 仍然在运行，等 p1.join 结束，可能p2、p3早已经结束了，这样 p2.join、p3.join 直接通过检测，无需等待。
所以3个join花费的总时间仍然是耗费时间最长的那个进程运行的时间。
上述启动进程与 join 进程可以简写为：
p_lis = [p1,p2,p3]
for p in p_l:
p.start()
for p in p_l:
p.join()
五、Process 对象的其他属性或方法
1，进程对象的 terminate 方法：
# terminate # 把进程干死
from multiprocessing import Process
import time,os
def task():
print("%s is running,parent id is <%s>." % (os.getpid(),os.getppid()))
time.sleep(3)
print("%s is done,parent id is <%s>." % (os.getpid(),os.getppid()))
if __name__ == "__main__":
p = Process(target=task,name="zoling")
p.start()
p.terminate() # 把它强制干死，也只是发信号给操作系统,真正的干死进程是要把它的内存空间回收掉，是操作系统的活
p.join()
print(p.is_alive())
print("主")
print(p.name) # 没指定进程名，它就会用默认的名，可以在造对象的时候给它起名字。
"""
False
主
zoling
"""2，进程对象的 is_alive 方法：
# 了解的方法(is_alive())
from multiprocessing import Process
import time,os
def task():
print("%s is running,parent id is <%s>." % (os.getpid(),os.getppid()))
time.sleep(3)
print("%s is done,parent id is <%s>." % (os.getpid(),os.getppid()))
if __name__ == "__main__":
p = Process(target=task,)
p.start()
print(p.is_alive())
p.join()
print("主", os.getpid(), os.getppid())
print(p.pid)
print(p.is_alive()) # 看进程是活着还是死了，返回布尔值
"""
True
2408 is running,parent id is <13084>.
2408 is done,parent id is <13084>.
主 13084 10776
2408
False
"""3，进程对象的 name 与 pid 属性：
from multiprocessing import Process
import time
def task(name):
print("%s is running." % name)
time.sleep(3)
print("%s is done." % name)
if __name__ == "__main__":
p = Process(target=task,args=("子进程1",),name="zoling")
p.start()
print("name:<%s>, id:<%s>" % (p.name, p.pid))
"""
name:<zoling>, id:<6032>
子进程1 is running.
子进程1 is done.
"""
六、练习题
1，思考开启进程的方式一和方式二各开启了几个进程？
2，进程之间的内存空间是共享的还是隔离的？下述代码的执行结果是什么？
from multiprocessing import Process
n = 100 # 在windows系统中应该把全局变量定义在if __name__ == '__main__'之上就可以了
def work():
global n
n = 0
print('子进程内: ',n)
if __name__ == '__main__':
p = Process(target=work)
p.start()
print('主进程内: ',n)
from multiprocessing import Process
n = 100 # 在windows系统中应该把全局变量定义在if __name__ == '__main__'之上就可以了
def work():
global n
n = 0
print('子进程内: ',n)
if __name__ == '__main__':
p = Process(target=work,)
p.start()
p.join() # 这里是为了确保子进程确确实实是运行了，因为 p.join 是主进程得等到子进程执行结束之后，才能执行。
print('主进程内: ',n)
# 子进程内: 0
# 主进程内: 100
# 证明了这两个进程之间的内存空间是相互隔离的result
3，基于多进程实现并发的套接字通信？
# -*- coding:utf-8 -*-
from socket import *
from multiprocessing import Process
def talk(conn):
while True:
try:
data = conn.recv(1024)
if not data:break
conn.send(data.upper())
except ConnectionResetError:
break
conn.close()
def server(ip,port):
server = socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server.bind((ip, port))
server.listen(5)
while True:
conn,addr = server.accept() # 主进程就专门干建链接的活
p = Process(target=talk,args=(conn,)) # 每建成一个链接，就启一个进程，干通信的活
p.start()
server.close()
if __name__ == "__main__": # 在 windows 系统下，开进程的操作一定要放到这个下面
server("192.168.2.209",8800)server端
# -*- coding:utf-8 -*-
from socket import *
client = socket(AF_INET,SOCK_STREAM)
client.connect(("192.168.2.209",8800))
while True:
msg = input(">>:").strip()
if not msg:continue
client.send(msg.encode("utf-8"))
data = client.recv(1024)
print(data.decode("utf-8"))client端
4，思考每来一个客户端，服务端就开启一个新的进程来服务它，这种实现方式有无问题？
5，改写下列程序，分别实现下述打印效果
from multiprocessing import Process
import time
import random
def task(n):
time.sleep(random.randint(1,3))
print('-------->%s' % n)
if __name__ == '__main__':
p1 = Process(target=task,args=(1,))
p2 = Process(target=task,args=(2,))
p3 = Process(target=task,args=(3,))
p1.start()
p2.start()
p3.start()
print('-------->4')1）效果一：保证最先输出-------->4
-------->4
-------->1
-------->3
-------->2
# 代码不用改，因为没有加 join 它会先执行主进程，子进程都在睡着。result
2）效果二：保证最先输出-------->4
-------->2
-------->3
-------->1
-------->4
# 加 join 控制让主进程等待
from multiprocessing import Process
import time
import random
def task(n):
time.sleep(random.randint(1,3))
print('-------->%s' % n)
if __name__ == '__main__':
p1 = Process(target=task,args=(1,))
p2 = Process(target=task,args=(2,))
p3 = Process(target=task,args=(3,))
p1.start()
p2.start()
p3.start()
p1.join()
p2.join()
p3.join()
print('-------->4')result
3）效果三：保证按顺序输出
-------->1
-------->2
-------->3
-------->4
from multiprocessing import Process
import time
import random
def task(n):
time.sleep(random.randint(1,3))
print('-------->%s' % n)
if __name__ == '__main__':
p1 = Process(target=task,args=(1,))
p2 = Process(target=task,args=(2,))
p3 = Process(target=task,args=(3,))
p1.start()
p1.join()
p2.start()
p2.join()
p3.start()
p3.join()
print('-------->4')result
6，判断上述三种效果，那种属于并发，那种属于串行？
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
