# 操作系统的发展历程
# 主要的人机矛盾是什么 : CPU的使用率
# 输入输出数据和CPU计算没有关系
# 操作系统是怎么进化的
# 传统的纸带输入
# 磁带的存储降低了输入输出数据占用的时间,提高了CPU的利用率
# 多道操作系统的出现 : 提高了CPU的利用率,单纯的切换会浪费时间
# 一台计算机上同时可以出现多个任务
# 能够将多个任务所使用的资源隔离开
# 当一个任务遇到输入输出工作的时候能够让另一个任务使用CPU去计算
# 分时操作系统 : 降低了cpu的利用率,提高了用户的体验
# 时间片轮转
# 实时操作系统
# 操作精密仪器或者设备
# 实时交易类
# 操作系统的作用
# 在具体的应用与所有的硬件之间起到了一个协调管理的作用
# 负责分配计算机中所有的资源
# 输入输出 Input/Output
# 向内存输入 : read,recv,recvfrom,import,input
# 从内存输出 : write,send,sendto,print
# CPU的工作效率和输入输出的工作效率差
# 并发和并行
# 多个程序交替在同一个cpu上被计算 并发
# 多个程序同时在多个cpu上被计算 并行
# 阻塞/非阻塞
# 阻塞 CPU不工作
# 非阻塞 CPU一直在工作
# 异步和同步
# 异步 :发布一个任务,不等待这个任务的结果就继续执行我的任务
# 同步 :发布一个任务,等待获取这个任务的结果之后才继续执行我的任务
# 同步阻塞/同步非阻塞/异步阻塞/异步非阻塞
# 进程和程序
# 进程就是运行中的程序
# 每一个进程在计算机中都有一个唯一的进程id,pid process id
# 进程 是计算机中资源分配的最小单位
# 三状态 : 就绪 运行 阻塞
# 线程 是计算机中能够被CPU调度的最小单位
# 是进程中的一个单位,它不能独立存在
使用Process类创建一个子进程
import os
import time
from multiprocessing import Process
def func(a,b,c):
time.sleep(1)
print(a,b,c,os.getpid(),os.getppid())
# pid : processid ppid : parent process id
# Process进程类
if __name__ == '__main__':
# windows操作系统下开启子进程子进程中的代码是通过import这种方式被导入到子进程中的
print('主 :', os.getpid())
Process(target=func,args=(1,2,3)).start()
# Process(target=func).start()
# Process(target=func).start()
如何开启多个子进程
import os
import time
from multiprocessing import Process
def func(a,b,c):
time.sleep(1)
print(a,b,c,os.getpid(),os.getppid())
if __name__ == '__main__':
# Process(target=func,args=(1,2,3)).start()
# Process(target=func,args=(2,3,4)).start()
# Process(target=func,args=(3,4,5)).start()
for i in range(1,4):
Process(target=func, args=(i, i+1, i+2)).start()
join方法
import time
import random
from multiprocessing import Process
def send_mail(name):
time.sleep(random.uniform(1,3))
print('已经给%s发送邮件完毕'%name)
if __name__ == '__main__':
lst = ['alex','yuan','宝元','太白']
阻塞等待一个子进程结束
p = Process(target=send_mail, args=('alex',))
p.start()
p.join() # 阻塞,直到p对应的进程结束之后才结束阻塞
print('所有的信息都发送完毕了')
p_l = []
for name in lst:
p = Process(target=send_mail,args=(name,))
p.start()
p_l.append(p)
for p in p_l : p.join()
print('所有的信息都发送完毕了')
守护进程
import time
from multiprocessing import Process
def func():
for i in range(20):
time.sleep(0.5)
print('in func')
def func2():
print('start : func2')
time.sleep(5)
print('end : func2')
if __name__ == '__main__':
p = Process(target=func)
p.daemon = True # 表示设置p为一个守护进程
p.start()
p2 =Process(target=func2)
p2.start()
print('in main')
time.sleep(3)
print('finished')
p2.join()
# 主进程和子进程互不干扰
# 主进程执行完毕之后程序不会结束,会等待所有的子进程结束之后才结束
# 为什么主进程要等待子进程结束之后才结束?
# 因为主进程要负责给子进程回收一些系统资源
# 守护进程 :
# 是一个子进程,守护的是主进程
# 结束条件 : 主进程的代码结束,守护进程也结束
# 进程
# 主进程的代码结束,守护进程结束
# 主进程要回收守护进程(子进程)的资源
# 主进程等待其他所有子进程结束
# 主进程回收所有子进程的资源
面向对象的方式实现多进程
import os
from multiprocessing import Process
class MyProcess(Process):
def run(self): # 希望在子进程中执行的代码就放在run方法中
print(os.getpid())
if __name__ == '__main__':
for i in range(10):
MyProcess().start()
import os
from multiprocessing import Process
class MyProcess(Process):
def __init__(self,a,b):
super().__init__()
self.a = a
self.b = b
def run(self): # 希望在子进程中执行的代码就放在run方法中
print(os.getpid(),self.a,self.b)
self.func()
if __name__ == '__main__':
for i in range(10):
MyProcess(1,2).start() # 通知操作系统开进程,执行run方法