python 多进程启动 python怎么开启多进程

运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。因此，运行起来的python程序也是一个进程，那么我们也可以在程序中再创建进程。多个进程可以实现并发效果，当我们的程序中存在多个进程的时候，在某些时候，就会让程序的执行速度变快。

在linux c语言中创建线程使用的fork函数，而Python就需要借助响应的模块

一、multiprocess模块

仔细说来，multiprocess不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多，为了方便大家归类记忆，我将这部分大致分为四个部分：创建进程部分，进程同步部分，进程池部分，进程之间数据共享。

二、multiprocess.process模块

process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。

三、Process类

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务(尚未启动)

强调：

需要使用关键字的方式来指定参数

args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

参数介绍：

group参数未使用，值始终为None

target表示调用对象，即子进程要执行的任务

args表示调用对象的位置参数元组，args=(1,2,'egon',)

kwargs表示调用对象的字典，kwargs={'name':'egon','age':18}

name为子进程的名称

3.1 方法介绍

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开启的进程

3.2 属性介绍

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字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功(了解即可)

3.3 在windows中使用Process类的注意事项

在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ =='__main__' 判断保护起来，import 的时候，就不会递归运行了。

四、process类的使用

在一个python进程中开启子进程，start方法和并发效果。

4.1 创建并开启子进程的两种方式

方式一：通过函数

from multiprocessing import Process
import time
'''

开启子进程的两种方式:

1. 通过函数

2. 通过类。继承Process

'''
def task(name):
print("进程{%s} start"%(name))
time.sleep(2)
print(f"进程{name} end")
# 必须加main
if __name__ == '__main__':
######## 方式1(通过函数)
p = Process(target=task,args=("xc",)) # args用于传参，是个元祖，必须加逗号
p.start() # 告诉操作系统启动子进程，但一定是父进程先执行，多个子进程的执行顺序是根据操作系统调度决定的
print('主进程/父进程')
print('主进程/父进程')
p1 = Process(target=task,args=("cyx",))
p1.start() # 告诉操作系统启动子进程，但一定是父进程先执行，多个子进程的执行顺序是根据操作系统调度决定的
print('主进程/父进程')
print('主进程/父进程')
print('主进程/父进程')
print('主进程/父进程')

方式二：通过类。继承Process

from multiprocessing import Process
import time
'''
开启子进程的两种方式:
1. 通过函数
2. 通过类。继承Process
'''
class myProcess(Process):
def __init__(self,name):
# self.name = name #错误 ### 这样没有给对象添加属性name，而是在修改父类的进程名(name)
# 父类Process的进程名也是name
super().__init__() # 调用父类super().init方法完成创建进程初始化，重新给name属性赋值了。
self.name = name ## 在父类的init方法后设置name，才是为自己对象添加属性
# super().__init__(name=name) # 调用父类super().init,并设置进程名(name)
def run(self): # 创建进程会默认调用run方法
print("进程%s start" % (self.name))
time.sleep(2)
print(f"进程{self.name} end")
# 必须加main
if __name__ == '__main__':
p = myProcess("xc")
p.start()
print('主进程/父进程')
print('主进程/父进程')
p1 = myProcess("cyx")
p1.start() # 告诉操作系统启动子进程，但一定是父进程先执行，多个子进程的执行顺序是根据操作系统调度决定的
print('主进程/父进程')
print('主进程/父进程')
print('主进程/父进程')
print('主进程/父进程')

4.2 join方法

join方法用于回收子进程

from multiprocessing import Process
import time
def foo(x):
print('进程 start ')
time.sleep(x)
print('进程 end ')
if __name__ == '__main__':
### 串行执行和回收子进程
# p = Process(target=foo, args=(1,))
# p2 = Process(target=foo, args=(2,))
# p3 = Process(target=foo, args=(3,))
# p.start() #
# p.join() # 阻塞住主进程再等待子进程结束，然后再往下执行，(了解的是：内部会待用wait())
# p2.start()
# p2.join()
# p3.start()
# p3.join()
# print('主')
# 并发执行进程，并依次回收
p = Process(target=foo, args=(1,))
p2 = Process(target=foo, args=(2,))
p3 = Process(target=foo, args=(3,))
# 开启进程
p.start()
p2.start()
p3.start()
# 回收进程
p.join() # 阻塞住主进程再等待子进程结束，然后再往下执行，(了解的是：内部会待用wait())
p2.join()
p3.join()
print('主')

4.3 查看主进程和子进程的进程号

from multiprocessing import Process,current_process
import time
import os
'''
查看主进程和子进程的进程号
1. 通过os.getpid()方法
2. 通过multiprocessing模块中的current_process().pid
'''
def task(name,x):
print("当前进程pid：", current_process().pid)
print(f"{name} start")
time.sleep(x)
print(f"{name} end")
if __name__ == '__main__':
p = Process(target=task,args=("进程1",1))
p.start()
# 方式一
print("子进程pid：",p.pid)
# 方式二
# print("当前进程pid：",current_process().pid)
print("当前进程pid",os.getpid())
print("主进程的父进程pid",os.getppid()) # 实际上是pycharm的进程号
print()

4.4 查看进程名和进程状态、设置进程名

'''
process设置名字: name属性
process判断进程是否存在：is_alive
'''
from multiprocessing import Process
import time
def task(x):
print("进程 start")
time.sleep(x)
print("进程 end")
if __name__ == '__main__':
p = Process(target=task,args=(1,))
p.start()
p.name = "进程1"
print(p.name)
print("子进程是否存在：", p.is_alive()) # True
time.sleep(2) # 延时2秒等待子进程结束
print("子进程是否存在：", p.is_alive()) # False
print("主进程")

4.5 terminate结束子进程

'''
terminate()
告诉子进程让他结束
'''
from multiprocessing import Process
import time
def task(x):
print("进程 start")
time.sleep(x)
print("进程 end")
if __name__ == '__main__':
p = Process(target=task,args=(10,))
p.start()
p.terminate() # 告诉子进程让他提前结束
p.name = "进程1"
print(p.name)
print("子进程是否存在：", p.is_alive()) # True
p.join()
print("子进程是否存在：", p.is_alive()) # False
print("主进程")

4.6 Process中的守护进程

首先，博主自己测试，实验。Process中守护进程的部分和真正的守护进程概念并不一样，因此只需要知道Process的守护进程即可。

'''
daemon = True 把子进程变为守护进程
主进程的代码执行完毕守护进程直接结束。但如果子进程代码结束也会结束
'''
from multiprocessing import Process
import time
def task(x):
print("进程 start")
time.sleep(x)
print("进程 end")
if __name__ == '__main__':
p = Process(target=task,args=(2,))
p.daemon = True # 把子进程变为守护进程
p.start()
# print(p.pid)
p.name = "进程1"
print(p.name)
print("子进程pid：", p.pid) #
print("子进程是否存在：", p.is_alive()) # True
time.sleep(3)
print("子进程是否存在：", p.is_alive()) # False
print("主进程")
print("子进程是否存在：", p.is_alive()) # False
time.sleep(200)

五、socket聊天并发实例

5.1 使用多进程实现socket聊天并发-server端

import socket
from multiprocessing import Process
def talk(conn,client_addr):
while 1:
msg = conn.recv(1024)
if not msg:
break
print(msg.decode("utf8"))
conn.send(msg.upper())
print(111)
if __name__ == '__main__':
# 必须要写在里面，不然会因为创建子线程重复调用导致端口被占用
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("127.0.0.1", 8087))
server.listen(5)
while 1:
print("等待连接")
conn,addr = server.accept()
print(addr,"连接成功")
p = Process(target=talk,args=(conn,addr))
p.start()

5.2 使用多进程实现socket聊天并发-client端

import socket
if __name__ == '__main__':
client = socket.socket()
client.connect(("127.0.0.1",8087))
while 1:
msg = input("请输入内容")
client.send(msg.encode("utf8"))
msg = client.recv(1024).decode("utf8")
print(msg)