python如何开启多进程_Python程序中的进程操作-开启多进程(multiprocess.Process)

运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。因此，运行起来的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)