本文内容皆为作者原创，如需转载，请注明出处：
一：必备知识回顾
1.计算机基础
计算机 又称之为 电脑，即 通电的大脑，发明计算机 是为了让它通电之后 能够像人一样去工作，并且它比人的工作效率更高，因为可以24小时不间断
2.计算机五大组成部分
控制器
运算器
存储器
输入设备
输出设备
计算机的核心真正干活的是CPU（控制器+运算器+存储器）
3.程序要想被计算机运行，它的代码必须要由硬盘先读到内存，之后CPU取指再执行
二：今日内容详细
1.操作系统的发展史
最早的计算机，穿孔卡片来存储数据
联机批处理系统
脱机批处理系统
参考博客即可：https://www.cnblogs.com/Dominic-Ji/articles/10929381.html
2.多道技术
单核 实现并发的效果
必备知识点：
1.并发
看起来像同时运行的就可以称之为“并发”
2.并行
真正意义上的 同时执行
PS：
并行肯定算并发
单核的计算机肯定不能实现并行，但是可以实现并发
补充：
我们直接假设：单核就是一个核，干活的就是一个人，不要考虑CPU里面的内核数
3.多道技术图解
节省多个程序运行的总耗时
4.多道技术重点知识
空间上的复用 与 时间上的 复用
空间上的复用：
多个程序公用一套计算机硬件
时间上的复用：
例子1：洗衣机30S，做饭50S，烧水30S 切换节省时间
单道：110S
多道：50S，多道只需要任务最长的那一个
例子2：边吃饭边玩游戏 保存状态
核心：
切换 + 保存状态
'''
切换（CPU）分为2种情况：
1.当一个程序遇到IO操作的时候，操作系统会剥夺该程序的CPU执行权限
作用：提高了CPU的利用率，并且也不影响程序的执行效率
2.当一个程序长时间占用CPU的时候，操作系统也会剥夺该程序的CPU执行权限
作用：降低了程序的执行效率（原本时间+切换时间）
'''
5.进程理论
必备知识点：
程序与进程的区别
'''
程序 就是一堆躺在硬盘上的代码，是“死”的
进程 则表示程序正在执行的过程，是“活”的
'''
进程调度：
先来先服务 调度算法
'''
对长作业有利，对短作业无益
'''
短作业优先调度算法
'''
对短作业有利，对长作业无益
'''
时间片轮转法 + 多级反馈队列
进程运行的三状态图
三：两对重要概念
同步和异步：
描述的是 任务的提交方式
同步：任务提交之后，原地等待任务的返回结果，等待的结果中不做任何事（干等着）
程序层面上 表现出来的感觉 就是卡住了
异步：任务提交之后，不原地等待任务的返回结果，直接去做其他事情，等待任务的返回结果自动提交给调用者
我提交的任务结果如何获取？
任务的返回结果 会有一个异步回调机制自动处理
同步例子：
import time
def func():
time.sleep(3)
print('Hello World')
if __name__ == '__main__':
res = func() # 同步调用
res
print('hahah')
阻塞和非阻塞：
描述的是 程序的运行状态
阻塞：阻塞态
非阻塞：就绪态、运行态
理想状态：我们应该让我们写的代码 永远处于 就绪态 和 运行态 之间切换
上述概念的组合：最高效的一种组合就是 异步 + 非阻塞
四：开启进程的2种方式
定心丸：代码开启进程 和 线程的方式，代码书写基本是一样的，你学会了如何开启进程，就学会了如何开启线程
第一种：
from multiprocessing import Process
import time
def task(name):
print(f'{name}' ' is running')
time.sleep(3)
print(f'{name}' ' is over')
# task(1)
if __name__ == '__main__':
# 创建进程的代码
# 1.创建一个对象
p = Process(target=task, args=('xxq',))
# 容器类型 无论里面有几个元素，一定要用逗号隔开，哪怕里面只有一个
# 2.开启进程
p.start() # 告诉操作系统 帮你创建一个进程 # 异步的感觉
print('主进程')
'''
Windows操作系统下 创建进程一定要在main内创建
因为Windows下创建进程 类似于 模块导入的方式
会从上往下 依次执行代码
Linux中则是直接将代码 完整地拷贝一份
'''
第二种:
# 第二种：
import time
from multiprocessing import Process
class MyProcess(Process):
def run(self):
print('Hello Beautiful Girl!')
time.sleep(1)
print('Get out')
if __name__ == '__main__':
p = MyProcess()
p.start()
print('主')
总结：
创建进程就是在内存中申请一块内存空间将需要运行的代码丢进去
一个进程对应在内存中就是一块独立的内存空间
多个进程对应在内存中就是多块独立的内存空间
进程与进程之间数据默认情况下是无法直接交互,如果想交互可以借助于第三方工具、模块
五：join方法
join是让主进程等待子进程代码运行结束之后，再继续运行。不影响其他子进程的执行
初阶版：
from multiprocessing import Process
import time
def task(name):
print(f'{name}' ' is running')
time.sleep(1)
print(f'{name}' ' is over')
if __name__ == '__main__':
p1 = Process(target=task, args=('xxq1',))
p2 = Process(target=task, args=('xxq2',))
p3 = Process(target=task, args=('xxq3',))
start_time = time.time()
p1.start()
p2.start()
p3.start()
print('主进程', time.time() - start_time)
xxq3 is running
xxq1 is running
xxq2 is running
xxq1 is over
xxq3 is over
xxq2 is over
进阶版：
from multiprocessing import Process
import time
def task(name):
print(f'{name}' ' is running')
time.sleep(3)
print(f'{name}' ' is over')
if __name__ == '__main__':
p1 = Process(target=task, args=('xxq1',))
p2 = Process(target=task, args=('xxq2',))
p3 = Process(target=task, args=('xxq3',))
start_time = time.time()
p1.start()
p2.start()
p3.start()
# time.sleep(5)
p1.join() # 主进程等待子进程p结束之后再继续往后执行
p2.join() # 主进程等待子进程p结束之后再继续往后执行
p3.join() # 主进程等待子进程p结束之后再继续往后执行
print('主进程', time.time() - start_time)
最终版：
from multiprocessing import Process
import time
def task(name, n):
print(f'{name}' ' is running')
time.sleep(n)
print(f'{name}' ' is over')
if __name__ == '__main__':
start_time = time.time()
p_list = []
for i in range(1, 4):
p = Process(target=task, args=(f'{i}', i))
p.start()
p_list.append(p)
for p in p_list:
p.join()
print('主进程', time.time() - start_time)
# 输出：
# 2 is running
# 1 is running
# 3 is running
# 1 is over
# 2 is over
# 3 is over
# 主进程 3.214817762374878
# 先全部同时执行，再关闭