Python编程进阶，Python如何实现多进程？

进程part1

• 1、进程介绍
  • 一、获取子父进程
  • 二、进程的基本使用
  • 二、建立带有参数的进程
  • 三、进程之间的数据彼此隔离
  • 四、多个进程之间的异步并发
• 2、join
  • 一、基本语法
  • 二、使用自定义类的方法建立进程
• 3、守护进程

 

不少人学习python，不知道从何学起。
不少人学习python，掌握了基本语法事后，不知道在哪里寻找案例上手。
不少已经作案例的人，殊不知道如何去学习更加高深的知识。
那么针对这三类人，我给你们提供一个好的学习平台，免费领取视频教程，电子书籍，以及课程的源代码！
QQ群：101677771

1、进程介绍

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

一、获取子父进程

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()

运行结果：
​

二、进程的基本使用

引用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()

运行结果：
​

二、建立带有参数的进程

在进程对象的建立处使用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()

运行结果：
​

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

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的操做没有影响到主进程

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

多个进程之间是异步并发的程序，由于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())

运行结果：
​

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

2、join

等待当前子进程所有执行完毕后，主进程再进行执行

一、基本语法

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("主进程执行完毕")

运行结果：
​

二、使用自定义类的方法建立进程

自定义进程类的要求：

• 必须继承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("主进程执行结束")

运行结果：
​

3、守护进程

守护进程守护的是主进程，若是主进程中的全部代码执行完毕了，当前这个守护进程会被马上杀死，当即终止。

语法：
进程.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("服务器出现异常！")

运行结果：
​