之前使用工具是jupyter导致执行效果和网络教程不一致,使用系统的python就可以达到效果
multiprocessing 是 Python 的标准模块，它既可以用来编写多进程，也可以用来编写多线程。如果是多线程的话，用 multiprocessing.dummy 即可，用法与 multiprocessing 基本相同.
基础
利用 multiprocessing.Process 对象可以创建一个进程,Process 类适合简单的进程创建，如需资源共享可以结合 multiprocessing.Queue 使用；如果想要控制进程数量，则建议使用进程池 Pool 类
Process 介绍：
构造方法：
Process([group [, target [, name [, args [, kwargs]]]]])
group: 线程组，目前还没有实现，库引用中提示必须是 None；
target: 要执行的方法；
name: 进程名；
args/kwargs: 要传入方法的参数。
实例方法：
is_alive()：返回进程是否在运行。
join([timeout])：阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的 timeout（可选参数）。
start()：进程准备就绪，等待 CPU 调度。
run()：strat() 调用 run 方法，如果实例进程时未制定传入 target，start 执行默认 run() 方法。
terminate()：不管任务是否完成，立即停止工作进程。
属性：
authkey
daemon：和线程的 setDeamon 功能一样（将父进程设置为守护进程，当父进程结束时，子进程也结束）。
exitcode(进程在运行时为 None、如果为 –N，表示被信号 N 结束）。
name：进程名字。
pid：进程号。
示例1:
import multiprocessing
def worker(num):
"""thread worker function"""
print('Worker:', num)
if __name__ == '__main__':
jobs = []
for i in range(5):
p = multiprocessing.Process(target=worker, args=(i,))
jobs.append(p)
p.start()
# 输出
# Worker: 1
# Worker: 0
# Worker: 2
# Worker: 3
# Worker: 4
#注意,测试时还是按照顺序执行,并没有出现序列无序情况
确定当前进程
每个Process实例都有一个名称，其默认值可以在创建进程时更改。命名进程对于跟踪它们非常有用，尤其是在同时运行多种类型进程的应用程序中
import multiprocessing
import time
def worker():
name = multiprocessing.current_process().name
print(name, 'Starting')
time.sleep(2)
print(name, 'Exiting')
def my_service():
name = multiprocessing.current_process().name
print(name, 'Starting')
time.sleep(3)
print(name, 'Exiting')
if __name__ == '__main__':
service = multiprocessing.Process(
name='my_service',
target=my_service,
)
worker_1 = multiprocessing.Process(
name='worker 1',
target=worker,
)
worker_2 = multiprocessing.Process( # default name
target=worker,
)
worker_1.start()
worker_2.start()
service.start()
# output
# worker 1 Starting
# worker 1 Exiting
# Process-3 Starting
# Process-3 Exiting
# my_service Starting
# my_service Exiting
守护进程
默认情况下，在所有子进程退出之前，主程序不会退出。有些时候，启动后台进程运行而不阻止主程序退出是有用的，例如为监视工具生成“心跳”的任务。
要将进程标记为守护程序很简单，只要将daemon属性设置为 True 就可以了。
import multiprocessing
import time
import sys
def daemon():
p = multiprocessing.current_process()
print('Starting:', p.name, p.pid)
sys.stdout.flush()
time.sleep(2)
print('Exiting :', p.name, p.pid)
sys.stdout.flush()
def non_daemon():
p = multiprocessing.current_process()
print('Starting:', p.name, p.pid)
sys.stdout.flush()
print('Exiting :', p.name, p.pid)
sys.stdout.flush()
if __name__ == '__main__':
d = multiprocessing.Process(
name='daemon',
target=daemon,
)
d.daemon = True
n = multiprocessing.Process(
name='non-daemon',
target=non_daemon,
)
n.daemon = False
d.start()
time.sleep(1)
n.start()
# output
# Starting: daemon 41838
# Starting: non-daemon 41841
# Exiting : non-daemon 41841
输出不包括来自守护进程的“退出”消息，因为所有非守护进程（包括主程序）在守护进程从两秒休眠状态唤醒之前退出。
守护进程在主程序退出之前自动终止，这避免了孤立进程的运行。这可以通过查找程序运行时打印的进程 ID 值来验证，然后使用 ps 命令检查该进程。
总体来讲,设置子进程为守护状态时,如果主进程退出(即发起子进程的主进程)退出,会把该进程发起的子进程杀死(如果该子进程还在运行).子进程未设置该状态,在子进程退出前,主进程不会退出
等待进程
要等到进程完成其工作并退出，请使用 join()方法
import multiprocessing
import time
import sys
def daemon():
name = multiprocessing.current_process().name
print('Starting:', name)
time.sleep(2)
print('Exiting :', name)
def non_daemon():
name = multiprocessing.current_process().name
print('Starting:', name)
print('Exiting :', name)
if __name__ == '__main__':
d = multiprocessing.Process(
name='daemon',
target=daemon,
)
d.daemon = True
n = multiprocessing.Process(
name='non-daemon',
target=non_daemon,
)
n.daemon = False
d.start()
time.sleep(1)
n.start()
d.join()
n.join()
# output
# Starting: non-daemon
# Exiting : non-daemon
# Starting: daemon
# Exiting : daemon
来源:https://juejin.im/post/5c07b27af265da611b58234c
https://www.cnblogs.com/chenhuabin/p/10074895.html
python 进程操作
创建进程有两种方式，分别是通过定义函数的方式和通过定义类的方式。两种方式创建进程都必须通过实例化Process类。
Process类参数如下：
1） group：这一参数值始终为None，尚未启用，是为以后Python版本准备的
2） target：表示调用对象，即子进程要执行的任务
3） args：表示调用对象的位置参数元组，即target的位置参数，必须是元组，如args=(0,1,[1,2,3])
4） kwargs:表示调用对象的字典参数,kwargs={'name':'egon','age':18}
5） name：为子进程的名称
通过定义函数的方式创建进程
from multiprocessing import Process
import time
def func(n):
print("子进程开始运行:{}……".format(n))
time.sleep(1)
print("子进程结束运行:{}……".format(n))
if __name__ == '__main__': # 创建进程执行一定要这一行代码
print("主进程开始运行……")
p = Process(target=func, args=(10,)) # 注册
p.start() # 启动一个子进程
time.sleep(1)
p.join()
print("主进程结束运行……")
##执行结果
主进程开始运行……
子进程开始运行:10……
子进程结束运行:10……
主进程结束运行……
##去掉p.join()
from multiprocessing import Process
import time
def func(n):
print("子进程开始运行:{}……".format(n))
time.sleep(1)
print("子进程结束运行:{}……".format(n))
if __name__ == '__main__': # 创建进程执行一定要这一行代码
print("主进程开始运行……")
p = Process(target=func, args=(10,)) # 注册
p.start() # 启动一个子进程
time.sleep(1)
print("主进程结束运行……")
#执行结果
主进程开始运行……
子进程开始运行:10……
主进程结束运行……
子进程结束运行:10……
##结论:
p.join() 会迫使主进程等待子进程执行完毕后才继续等待,即子进程执行完毕后主进程才继续执行
通过定义类的方式创建进程
from multiprocessing import Process
import os,time
class MyProcess(Process):
def __init__(self , arg1 , arg2):
super().__init__()
self.arg1 = arg1
self.arg2 = arg2
def run(self):
print('子进程:' , self.pid , self.arg1 , self.arg2)
print("沉睡中...")
time.sleep(3)
if __name__ == "__main__" :
p1 = MyProcess('我是arg1' , '我是arg2')
p1.start()
p2 = MyProcess('我是arg1' , '我是arg2')
p2.start()
print('主进程：', os.getpid())
print("主进程结束")
##一般先执行主进程中的操作,然后才执行子进程,但是如果主进程阻塞,子进程就会线执行(不添加p.join())
Process****的常用属性和方法
Process类常用属性如下：
1）daemon：默认值为False，如果设为True，则设为守护进程。
2）name:进程的名称
3）pid：进程的pid
Process类常用方法如下：
1）start()：启动进程，并调用该子进程中的p.run() ；
2 ）run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法；
3 ）terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁；
4）is_alive():如果p仍然运行，返回True；
5）join([timeout]):主线程等待子进程终止
守护进程：daemon
若要将一个进程设置为守护进程，在进程start之前，将其daemon属性设置为True即可。但什么是守护进程呢？我们通过如下代码来说明，我们要通过代码实现如下效果：主进程创建p1、p2进程，之后立马沉睡5秒，p1进程设置为守护进程，进程p1每隔1秒打印一条语句，进程p2打印一条语句后立马沉睡10秒。代码如下：
import time
import os
from multiprocessing import Process
def func():
i = 1
while True:
time.sleep(1)
print('{}--子进程p1正在执行,pid:{}'.format(i , os.getpid()))
i+=1
def func2():
print('子进程p2开始执行,pid:{}'.format(os.getpid()))
time.sleep(10)
print('子进程p2结束执行,pid:{}'.format(os.getpid()))
if __name__=='__main__':
print('主进程代码开始运行,pid:{}'.format(os.getpid()))
p = Process(target=func)
p.daemon = True # 设置为守护进程
p.start()
p2 = Process(target=func2)
p2.start()
time.sleep(5)
print('主进程代码运行完了,pid:{}'.format(os.getpid()))
##
运行结果：
主进程代码开始运行,pid:11608
子进程p2开始执行,pid:7260
1--子进程p1正在执行,pid:1060
2--子进程p1正在执行,pid:1060
3--子进程p1正在执行,pid:1060
4--子进程p1正在执行,pid:1060
主进程代码运行完了,pid:11608
子进程p2结束执行,pid:7260
从运行结果字面上似乎看不出什么，因为区别在于输出时间上。在主进程运行的那5秒时间（输出“主进程代码运行完了,pid:11608”之前），p1进程确实可以每隔1秒输出一条语句，但是主进程结束那5秒后，p1不在输出，且在任务管理器中也可以查看到，p1进程也已经死亡，主进程代码虽然运行完了，但依然存活，这时候p2进程依然还在沉睡，10秒后，p2进程打印“子进程p2结束执行,pid:7260”，然后主进程和p2进程一起死亡。
可以得出结果，守护进程依附于主进程代码，只要主进程代码运行完了，那么无论守护进程代码是否运行完，守护进程都会结束。另外，守护进程不能创建自己的子进程。
进程终结于存活检查：terminate()与is_alive()
terminate()与is_alive()都是由进程实例调用，分别用来终结一个进程、检查一个进程是否依然存活：
import time
import os
from multiprocessing import Process
def func():
i = 1
while True:
time.sleep(1)
print('{}--子进程p1正在执行,pid:{}'.format(i , os.getpid()))
i+=1
if __name__=='__main__':
p = Process(target=func)
p.start()
time.sleep(3)
p.terminate() # 终结进程p
print(p.is_alive()) # 检查p是否依然存活
time.sleep(1)
print(p.is_alive())
##输出结果：
主进程代码开始运行,pid:13164
1--子进程p1正在执行,pid:8896
2--子进程p1正在执行,pid:8896
True
False
主进程代码运行完了,pid:13164
为什么结束之后第一次调用is_alive()方法输出的是True呢？因为terminate()方法终结一个进程时操作系统需要一定的响应时间，所以可能会有延迟
join()方法
join方法功能是阻塞当前所在进程（例如下面的主进程），等到被join的进程（下面的进程p1）结束之后，回到当前进程继续执行。
from multiprocessing import Process
import time
def func1 ():
print("进程1开始运行……")
for i in range(3):
time.sleep(1)
print("进程1运行了{}秒……".format(i+1))
print("进程1结束运行……")
def func2 ():
print("进程2开始运行……")
for i in range(6):
time.sleep(1)
print("进程2运行了{}秒……".format(i+1))
print("进程2结束运行……")
if __name__ == '__main__':
print("主进程开始运行……")
p1 = Process(target=func1)
p2 = Process(target=func2)
p1.start()
p2.start()
time.sleep(1)
p1.join()
# p2.join()
print("主进程结束运行……" )