一.进程
进程就是正在运行的程序,它是操作系统中,资源分配的最小单位.
进程号是进程的唯一标识
进程和进程之间的关系: 数据彼此隔离,通过socket通信
并发:一个cpu同一时间不停执行多个程序
并行:多个cpu同一时间不停执行多个程序
cpu的进程调度方法:
先来先服务fcfs(first come first server):先来的先执行
短作业优先算法:分配的cpu多,先把短的算完
时间片轮转算法:每一个任务就执行一个时间片的时间.然后就执行其他的.
多级反馈队列算法
越是时间长的,cpu分配的资源越少,优先级靠后
越是时间短的,cpu分配的资源越多
进程的三状态:就绪,运行,阻塞
import os,time,random
ps -aux 查看进程号
ps -aux | grep 进程号
kill -9 进程号
获取当前进程id(子进程)
res = os.getpid()
print(res)
获取当前进程的父进程
res = os.getppid()
print(res)
1.进程的基本使用
from multiprocessing import Process
def func():
print("1.子进程id>>{},2.父进程id>>{}".format(os.getpid(), os.getppid()))
# 为了解决Windows和Linux系统的兼容问题,下面这句话必须加上,否则报错
if __name__ == '__main__':
# 创建子进程,返回进程对象,执行func这个任务
p = Process(target=func)
# 调用子进程
p.start()
2.创建带有参数的进程
def func(n):
for i in range(1, n+1):
print("1.子进程id>>{},2.父进程id>>{}".format(os.getpid(), os.getppid()))
if __name__ == '__main__':
n = 5
# 创建子进程
p = Process(target=func, args=(n,))
# 调用子进程
p.start()
for i in range(1, n+1):
print("*" * i)
3.进程之间的数据彼此隔离
count = 10
def func():
global count
count += 1
print("我是子进程count={}".format(count))
if __name__ == '__main__':
p = Process(target=func)
p.start()
time.sleep(1)
print(count)
4.多个进程之间是异步并发
多个进程之间是异步并发的程序,因为CPU的调度策略问题,不一定哪个任务先执行,哪个任务后执行.
整体而言,主进程比子进程创建的速度要快,CPU遇到阻塞会立刻切换任务,等到阻塞态的任务变成了就绪态,CPU再回来执行
主程序会默认等到所有的子程序执行结束之后,再统一关闭程序,释放资源.
若不等待,有可能在后台有多个未执行结束的子进程,会变成僵尸进程,不停的占用CPU,内存
增加系统的压力,所以方便于对进程的管理,主程序默认等待子进程.
def func(n):
time.sleep(random.randrange(3))
print("数字{}<=>1.子进程id>>{},2.父进程id>>{}".format(n, os.getpid(), os.getppid()))
if __name__ == '__main__':
for i in range(1, 11):
Process(target=func, args=(i,)).start()
print("主进程执行结束了...")
print(os.getpid())
二.join
join等待当前子进程全部执行完毕之后,主进程再执行(用来同步子父进程的)
from multiprocessing import Process
import time,os
1.join基本语法
def func():
print("发送第一封邮箱,要求涨工资")
if __name__ == '__main__':
p = Process(target=func)
p.start()
# 必须等待子进程全部执行结束之后,再执行主进程中的代码,用join来
p.join()
# time.sleep(1)
print("发送第二封邮箱,涨到一个月6万")
2.多个子进程的场景中使用join
def func(i):
time.sleep(1)
print("发送第%s封邮件,要求升职加薪" % (i))
if __name__ == '__main__':
lst = []
for i in range(10):
p = Process(target=func, args=(i,))
p.start()
lst.append(p)
for i in lst:
i.join()
print("主进程发最后一封邮件:此致敬礼~")
三.使用自定义类的方法创建进程
自定义进程类的要求:
(1)必须继承Process这个父类
(2)所有进程必须执行的逻辑必须写在run方法里面
1.基本语法
class MyProcess(Process):
def run(self):
print("1.子进程id>>{},2.父进程id>>{}".format(os.getpid(), os.getppid()))
if __name__ == '__main__':
p = Process()
p.start()
print("3.子进程id>>{},4.父进程id>>{}".format(os.getpid(), os.getppid()))
2.带有参数自定义类的方法
class MyProcess(Process):
def __init__(self, arg):
# 手动调用一下父类的构造方法(最终实现进程的创建)
super().__init__()
self.arg = arg
def run(self):
print("1.子进程id>>{},2.父进程id>>{}".format(os.getpid(), os.getppid()))
print(self.arg)
if __name__ == '__main__':
p = MyProcess("我是传进来的参数")
p.start()
print("3.子进程id>>{},4.父进程id>>{}".format(os.getpid(), os.getppid()))
四.守护进程
守护进程守护的是主程序,如果主程序中的所有代码执行完毕了,
当前这个守护进程会被立刻杀死,立刻终止.
语法:
进程.daemon = True 设置当前这个进程为守护进程
必须写在start()调用进程之前进行设置
默认:主进程会默认等待所有子进程执行结束之后,再关闭程序,释放资源
from multiprocessing import Process
import time
1.基本使用
def func():
print("start当前子进程")
time.sleep(1)
print("end当前子进程")
if __name__ == '__main__':
p = Process(target=func)
p.daemon = True
p.start()
print("主程序执行结束...")
2.多个子进程的场景
def func1():
count = 1
while True:
print("*" * count)
time.sleep(0.5)
count += 1
def func2():
print("start func2 当前子进程任务")
time.sleep(3)
print("end func2 当前子进程任务")
if __name__ == '__main__':
p1 = Process(target=func1)
p2 = Process(target=func2)
# 设置p1这个进程对象为守护进程
p1.daemon = True
p1.start()
p2.start()
time.sleep(1)
print("主进程执行结束...")
3.守护进程实际用途:监控报活
# 守护进行
def alive():
while True:
print("给监控的总服务器发消息,报告自己的存活状态,i am alive~")
time.sleep(1)
# 执行任务
def func():
while True:
try:
time.sleep(1)
raise RuntimeError
# print("当前5号服务器功能:对日志进行数据分析...")
except:
break
if __name__ == '__main__':
# 创建2个子进程
p1 = Process(target=alive)
p2 = Process(target=func)
# 设置p1为守护进程
p1.daemon = True
p1.start()
p2.start()
# 必须等到p2任务执行结束之后,再向下执行
p2.join()
print("当前服务器状态异常...")