之前的文章中有提到单进程和多进程、单线程和多线程之间的关系，想必大家对此应该也有了一定的了解。那么，这篇文章我将带大家深入了解多进程多线程的运行，以及运行后会发生什么情况，出现了问题如何解决更为妥当？
1. 多任务运行控制
1.1. 等待子任务结束
进程或者线程添加join方法之后，会等待子任务结束，如果没有结束，则会阻塞，直到子任务结束，因此join一般都是放在程序的最后。
p1.join()：主进程等待子任务运行完毕
# 加p1.join()，子进程结束了，主进程才结束
# outputs:
# outer-start: Wed Dec 1 20:05:48 2021
# inner-start: Wed Dec 1 20:05:48 2021
# inner-end: Wed Dec 1 20:05:58 2021
# outer-end: Wed Dec 1 20:05:58 2021
# 未加p1.join()，什么都没加的话，主进程先结束，子进程后结束
# outputs:
# outer-start: Wed Dec 1 20:05:08 2021
# inner-start: Wed Dec 1 20:05:08 2021
# outer-end: Wed Dec 1 20:05:13 2021
# inner-end: Wed Dec 1 20:05:18 2021
1.2. 获取当前进程
在进程内容处获取当前进程，方便查找问题。
print(multiprocessing.current_process())：获取当前进程对象，与下方的name对应
1.3. 任务名字
修改与添加用户的名字，起到表示作用。
p1.name = '进程1号'：子进程名为进程1号
1.4. 终止任务
在正常情况下，主进程的结束，并不会影响子进程，但是也可以在主进程结束之后，强制终止子进程。
p1 = multiprocessing.Process(target=func)：实例化进程对象传给变量p1
p1.terminate()：主进程结束时，强制关闭子进程
注意线程不能终止，只能等待结束。
import time
import multiprocessing
def new_time():
"""格式化时间"""
return time.asctime(time.localtime(time.time()))
def func():
print('inner-start:',new_time())
time.sleep(10) # 休眠，模拟io耗时操作
print('inner-end:',new_time())
print('outer-start:',new_time())
p1 = multiprocessing.Process(target=func)
p1.start()
time.sleep(5)
# p1.terminate() # 主进程结束时，强制关闭子进程
# p1.join() # 主进程等待子任务运行完毕
# 加p1.join()，子进程结束了，主进程才结束
# outputs:
# outer-start: Wed Dec 1 20:05:48 2021
# inner-start: Wed Dec 1 20:05:48 2021
# inner-end: Wed Dec 1 20:05:58 2021
# outer-end: Wed Dec 1 20:05:58 2021
# 未加p1.join()，也什么处理方式都没加，则主进程先结束，子进程后结束
# outputs:
# outer-start: Wed Dec 1 20:05:08 2021
# inner-start: Wed Dec 1 20:05:08 2021
# outer-end: Wed Dec 1 20:05:13 2021
# inner-end: Wed Dec 1 20:05:18 2021
res = input("是否需要继续等待子进程执行y/n：")
if res == 'y':
p1.join() # 主进程等待子任务运行完毕
elif res == 'n':
p1.terminate() # 主进程结束时，强制关闭子进程
else:
print('请选择正确选项')
print('outer-end:',new_time())
2. 多任务标识
2.1. 进程的pid
在Linux中，只要进程一创建，系统就会分配一个pid，在程序运行过程中，pid都不会改变。
可以通过pid查看进程对资源的使用情况，也可以通过pid来控制进程的运行。
import time
import multiprocessing
def new_time():
"""格式化时间"""
return time.asctime(time.localtime(time.time()))
def func():
print('inner-start:',new_time())
# print(multiprocessing.current_process()) # 获取当前进程对象
# outputs:<Process(进程1号, started daemon)>
time.sleep(10) # 休眠，模拟io耗时操作
print('inner-end:',new_time())
print('outer-start:',new_time())
# print(multiprocessing.current_process()) # 获取当前进程对象
# outputs:<_MainProcess(MainProcess, started)>
p1 = multiprocessing.Process(target=func,daemon=True) # 守护模式daemon，开启守护模式之后，主进程结束，子进程会自动结束，与terminate比起来更加合适
# p1.name = '进程1号' # 改进程名
print('before start:',p1.pid) # 查找进程id
p1.start()
print('after start:',p1.pid)
time.sleep(5)
print('outer-end:',new_time())
2.2. 线程ident
线程是在一个进程当中，所以不会有pid。
线程由python解释器调度，为了调度方便，会有ident类似于操作系统中的pid。
import time
import threading
def new_time():
"""格式化时间"""
return time.asctime(time.localtime(time.time()))
def func():
print('inner-start:',new_time())
time.sleep(10) # 休眠，模拟io耗时操作
print('inner-end:',new_time())
print('outer-start:',new_time())
t1 = threading.Thread(target=func)
print('before start:',t1.ident) # 查找线程id
t1.start()
print('after start:',t1.ident)
time.sleep(5)
print('outer-end:',new_time())
2.3. 生命周期
进程的生命周期开始于start启动，实例化之后，进程并没有启动，只有启动之后才开始有生命周期。
import time
import multiprocessing
def new_time():
"""格式化时间"""
return time.asctime(time.localtime(time.time()))
def func():
print('inner-start:',new_time())
time.sleep(10) # 休眠，模拟io耗时操作
print('inner-end:',new_time())
print('outer-start:',new_time())
p1 = multiprocessing.Process(target=func)
print('before start:',p1.is_alive())
# outputs:
# False
p1.start()
print('after start:',p1.is_alive())
# outputs:
# True
time.sleep(5)
print('outer-end:',new_time())
3. 守护模式
开启守护模式之后，主进程结束，子进程会自动结束。
p1 = multiprocessing.Process(target=func,daemon=True)：daemon=True开启守护模式
import time
import multiprocessing
def new_time():
"""格式化时间"""
return time.asctime(time.localtime(time.time()))
def func():
print('inner-start:',new_time())
# print(multiprocessing.current_process()) # 获取当前进程对象
# outputs:<Process(进程1号, started daemon)>
time.sleep(10) # 休眠，模拟io耗时操作
print('inner-end:',new_time())
print('outer-start:',new_time())
# print(multiprocessing.current_process()) # 获取当前进程对象
# outputs:<_MainProcess(MainProcess, started)>
p1 = multiprocessing.Process(target=func,daemon=True) # 守护模式daemon，开启守护模式之后，主进程结束，子进程会自动结束，与terminate比起来更加合适
# p1.name = '进程1号' # 改进程名
print('before start:',p1.pid) # 查找进程id
p1.start()
print('after start:',p1.pid)
time.sleep(5)
print('outer-end:',new_time())
4. 面向对象编程
在使用多进程或者多线程时，对应模块可以直接使用，也可以继承之后，自己定制使用。
import redis
import multiprocessing
class RedisProcess(multiprocessing.Process): # 继承进程类
def __init__(self,db,key,value):
super().__init__() # 利用父类的初始化赋值，使我们的实例对象可以成为完整的子进程对象
self.connect = redis.Redis(db=db) # 连接redis非关系型数据库
self.key = key
self.value=value
def set(self):
self.connect.set(self.key,self.value)
def run(self): # 重写了父类multiprocessing.Process里的run方法,如下方start()即可调用
import time
time.sleep(5)
self.set()
myredis1 = RedisProcess(5,'ch','age18')
myredis2 = RedisProcess(6,'bd','age38')
myredis1.start()
myredis2.start()
myredis1.join()
myredis2.join()
# flushall 在linux里运行，则所有redis库数据都消失
文章到这里就结束了！希望大家能多多支持Python（系列）！六个月带大家学会Python，私聊我，可以问关于本文章的问题！以后每天都会发布新的文章，喜欢的点点关注！一个陪伴你学习Python的新青年！不管多忙都会更新下去，一起加油！
Editor：Lonelyroots
网友评论