Python实现多进程part1

一、进程介绍

进程就是正在运行的程序，它是操作系统中，资源分配的最小单位
资源分配：分配的是cpu和内存等物理资源，进程号是进程的唯一标识
获取当前进程–子进程
异步和同步：

1、获取子父进程

os.getpid()

获取当前进程的父进程

os.getppid()

为解决Windows系统和Linux系统的兼容问题，下面这句话必须加上：
__name__ == “__main__”

def func():
	res1=os.getpid()
	res2=os.getppid()
	print(res1,res2)
#创建子进程，返回进程对象,执行func这个任务
if __name__ == "__main__":
	P=Process(target=func)
	P.start()

运行结果：

2、进程的基本使用

引用multiprocessing模块来创建以一个进程：

from multiprocessing import Process
import os
def func():
	print("子进程为>>{},父进程为>>{}".format(os.getpid(),os.getppid()))
#为解决系统兼容性问题，必须加下面这句话
if __name__ == "__main__":
	#创建子进程，返回进程对象，执行func这个任务
	p=Process(target=func)
	#调用子进程
	p.start()

运行结果：

2、创建带有参数的进程

在进程对象的创建处使用args进行传参

from multiprocessing import Process
import os
def func(m,n):
	print("子进程为>>{},父进程为>>{}".format(m,n))
#为解决系统兼容性问题，必须加下面这句话
if __name__ == "__main__":
	#创建子进程，返回进程对象，执行func这个任务
	p=Process(target=func,args=(os.getpid(),os.getppid()))
	#调用子进程
	p.start()

运行结果：

3、进程之间的数据彼此隔离

from multiprocessing  import Process
import time
count=0
def func():
	global count
	count += 1
	print("count:{}".format(count))
if __name__ == "__main__":
	p=Process(target=func)
	p.start()
	time.sleep(1)
	print(count)

运行结果：

如图，子进程对count的操作没有影响到主进程

4、多个进程之间的异步并发

多个进程之间是异步并发的程序，因为cpu的调度策略问题，不一定哪个程序先执行，哪个程序后执行
整体而言，主进程比子进程创建的速度要快，cpu遇到阻塞会立即切换任务，等到阻塞态的任务变成了就绪态，cpu再回来执行
主程序会默认等到所有子程序执行结束之后，再统一关闭程序，释放资源
若不等待，有可能在后台存有多个未执行结束的子进程，会变成僵尸进程，不停的占用cpu和内存。

import time,random,os
from multiprocessing import Process
def func(n):
	time.sleep(random.randrange(3))
	print("{},子进程:{},父进程:{}".format(n,os.getpid(),os.getppid()))
if __name__ == "__main__":
	for i in range(10):
		p=Process(target=func,args=(i,))
		p.start()
	print("主程序结束了")
	print(os.getpid())

运行结果：

如图，因为多个进程之间是异步并发的，所以会产生以上结果

二、join

等待当前子进程全部执行完毕后，主进程再进行执行

1、基本语法

import os,time
from multiprocessing import Process
def func1():
	print("子进程:{}".format(os.getpid()))
def func2():
	time.sleep(0.5)
	print("父进程:{}".format(os.getppid()))
if __name__ == "__main__":
	p1=Process(target=func1)
	p2=Process(target=func2)
	p1.start()
	p2.start()
	#引入join，所有子进程执行完成后执行主进程
	p1.join()
	p2.join()
	print("主进程执行完毕")

运行结果：

2、使用自定义类的方法创建进程

自定义进程类的要求：

• 必须继承Process这个父类
• 所有进程执行任务的逻辑必须写在run方法里面

基本写法：

import os,time
from multiprocessing import Process
class MyProcess(Process):
	def run(self):
		print("子进程:{},父进程:{}".format(os.getpid(),os.getppid()))
if __name__ == "__main__":
	p=MyProcess()
	p.start()
	p.join()
	print("主进程执行结束")

带有参数自定义类的方法：

import os,time
from multiprocessing import Process
class MyProcess(Process):
	def __init__(self,arg):
		self.arg=arg
		super().__init__()
	def run(self):
		print(self.arg)
		print("子进程:{} 主进程:{}".format(os.getpid(),os.getppid()))
if __name__=="__main__":
	p=MyProcess(arg="我是传参")
	p.start()
	p.join()
	print("主进程执行结束")

运行结果：

三、守护进程

守护进程守护的是主进程，如果主进程中的所有代码执行完毕了，当前这个守护进程会被立刻杀死，立即终止。

语法：
进程.daemon = True 设置当前这个进程为守护进程
必须在start()调用进程之前进行设置

默认：主进程会等待所有子进程执行结束后，再关闭程序，释放资源

from multiprocessing import Process
import time
def func1():
	while True:
		time.sleep(0.5)
		print("我是守护进程！")
def func2():
	time.sleep(3)
	print("我是子进程！")
if __name__ == "__main__":
	p1=Process(target=func1)
	p2=Process(target=func2)
	p1.daemon=True
	p1.start()
	p2.start()
	time.sleep(2)
	print("主进程执行")

运行结果：

案例：
监控报活: 利用守护进程特性，监控日志分析服务器是否存活

from multiprocessing import Process
import time
def alive():
	while True:
		time.sleep(0.5)
		print("P1:服务器存活...")
def func():
	count=0
	while True:
		try:
			time.sleep(0.5)
			print("P2:服务器日志分析中...")
			time.sleep(1)
			count += 1
			if count == 3:
				raise RuntimeError
		except:
			break
if __name__ == "__main__":
	p1=Process(target=alive)
	p2=Process(target=func)
	p1.daemon=True
	p1.start()
	p2.start()
	p2.join()
	print("服务器出现异常！")

运行结果：