多道技术
1.空间上的复用
多个程序共用一套计算机硬件
多道技术原理
2.时间上的复用
切换+保存状态
1.当一个程序遇到IO操作 操作系统会剥夺该程序的CPU执行权限( 提高了CPU的利用率，并且也`不影响程序的执行效率` )
2.当一个程序长时间占用CPU 操作系统也会剥夺该程序的CPU执行权限( `降低了程序的执行效率` )
并发: 看起来像同时运行就可以
并行: 真正意义上的同时运行
单核的计算机不能实现并行，但是可以实现并发
进程
程序和进程的区别
程序: 一段代码
进程: 正在进行的程序 进程相互独立
进程调度
要想多个进程交替运行，操作系统必须对这些进程进行调度，这个掉浮是遵循一定法则的，这就是进程的调度算法
-
先来先服务 （最简单的调度算法，有利于长作业，不利于短作业）
-
短作业优先算法（短作业优先，对短作业有利，对长作业不利）
-
时间片轮转法+多级反馈队列
时间片: 就好比将一秒等分成N多份如果一个程序他需要更多的时间片，这个程序的执行优先级就会下降，比如A程序在运行，此时用户点击了B程序，那操作系统就会立刻停止A程序的执行，保存A程序的运行进度，然后去响应B程序
-
大概就这些？
进程三态状态转换图
在了解其他概念之前，我们首先要了解进程的几个状态。在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态：就绪，运行和阻塞。
（1）就绪(Ready)状态
当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。
（2）执行/运行（Running）状态当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。
（3）阻塞(Blocked)状态正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。
引起进程阻塞的事件可有多种，
例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)
input
print
文件操作
sleep
...其他的
结束阻塞态
input获取到值
print输出完结果
文件读取完毕
睡眠结束。
时间片的时间到了（占用CPU太久了）会自动进入就绪态，而不是阻塞，等待下一次CPU执行
写程序的理想状态: 尽量少的进入阻塞态
同步异步
表示的是任务的提交方式
同步：任务提交以后，原地等待的任务的执行并拿到返回结果才走，期间不做任何事（程序界面的表现就是
异步：任务提交以后，不再原地等待，而是继续执行下一行代码（结果是要的 但是用其他方式获取）
import time
def test()
time.sleep()
res = test()
print('hello')
阻塞非阻塞
表示的是程序的运行状态
阻塞: 对应进程三状态中的阻塞态
非阻塞: 对应进程三状态中的就绪态、运行态
异步非阻塞形式效率最高
创建进程的两种方式
创建进程就是在内存中重新开辟一块内存空间
将运行产生的代码丢进去
一个进程对应在内存就是一块独立的内存空间
进程与进程之间数据是隔离的，无法直接交互，可以通过某些技术实现间接交互
这两种必须敲出来
from multiprocessing
...
def test(name):
print('%s is running' %name)
time.sleep(3)
print('%s is over' %name)
"""
Windows 创建进程会将代码以模块的方式从上往下执行一遍
Linux 会直接将代码完完整整的拷贝一份（fork一份）
windows创建进程一定要在 if __name__ == '__main__': 代码块内创建 否则报错
"""
if __name__ == '__main__':
p = Process(target = test,args = ('margo',)) # 创建一个进程对象
p.start() # 告诉操作系统帮你创建一个进程
print('主') # 为什么先打印’主‘
#因为创建p.start()这个进程的时间远远大于执行接下来语句的时间
"""
创建进程就是在内存中重新开辟一块内存空间
将允许产生的代码丢进去
一个进程对应在内训就是一块独立的内存空间
进程与进程之间数据是隔离的 无法直接交互
( 可以通过某些技术间接进行交互 )
只要开一个进程 就是重新申请一块内存空间
零散知识点
join方法
from multiprocessing import Process
from multiprocessing import Process
def test(name):
print('%s is running'% name)
time.sleep(3)
print('%s is over'% name)
p = Prosess(target = test,args = ('margo',))
p.start()
print('主')
# 这样会报错 要把三行 放在main里面
if __name__ == '__main__':
p = Prosess(target = test,args = ('margo',))
p.start()
# 主进程代码等待子进程运行结束 才继续进行
print('主')
# 用join
if __name__ == '__main__':
p = Prosess(target = test,args = ('margo',))
p.start()
# 主进程代码等待子进程运行结束 才继续进行
p.join()
print('主')
if __name__ == '__main__':
p = Prosess(target = test,args = ('margo',))
p1 = Prosess(target = test,args = ('margo',))
p2 = Prosess(target = test,args = ('margo',))
p.start() # 仅仅是告诉操作系统帮你创建一个进程
p1.start() # 创建进程的顺序是随机的
p2.start() # 至于这个进程什么时候创，操作系统随机决定
# 主进程代码等待子进程运行结束 才继续进行
p.join()
print('主')
if __name__ == '__main__':
for i in range(3):
p = Process(target = )
p = Prosess(target = test,args = ('margo',))
p1 = Prosess(target = test,args = ('margo',))
p2 = Prosess(target = test,args = ('margo',))
p.start() # 仅仅是告诉操作系统帮你创建一个进程
p1.start() # 创建进程的顺序是随机的
p2.start() # 至于这个进程什么时候创，操作系统随机决定
# 主进程代码等待子进程运行结束 才继续进行
p.join()
print('主')
06 进程间数据是隔离的
money = 100
07 进程对象及其他方法
查看 主主进程
getpid getppid
杀死进程
terminate 杀死当前进程 其实是告诉操作系统
time.sleep(0.1)
p.is_alive()
僵尸进程与孤儿进程
父进程回收子进程资源的两种方式：
1.join方法
2.父进程正常死亡
所有的进程都会步入僵尸进程
孤儿进程
子进程没死 父进程意外死亡
针对Linux会有儿童福利院(init)(只是个名字 别搞混)，如果父进程意外死亡，他所创建的子进程都会被福利院收养
守护进程
被守护进程结束后守护进程立刻结束（后面的还未执行的代码直接不执行了）
from multiprocessing import Process
import time
# 古代皇帝死了一般太监都需要陪葬，所以举这么一个例子
def test(name):
print(f'{name}总管正常活着')
time.sleep(3)
print(f'{name}总管正常死亡')
# # windows下创建子进程必须卸载 __main__ 这个结构里
# if __name__ == '__main__':
# p = Process(target=test, args=('margo', ))
# p.start()
# print(f"皇帝bitten寿终正寝")
#
# # 皇帝bitten寿终正寝
# # margo总管正常活着
# # margo总管正常死亡
# # 加上p.daemon = True 让子进程成为守护进程
# if __name__ == '__main__':
# p = Process(target=test, args=('margo', ))
# p.daemon = True # 将该进程设置为守护进程，这一句必须放在start()之前，否则报错
# p.start()
# # 守护进程一般不加 p.join，都等子进程运行完了再接着走主进程那就不是守护进程了
# # p.join() # 加了也能正常运行，但它失去了守护进程的意义
# print(f"皇帝bitten寿终正寝")
#
# # 皇帝bitten寿终正寝
# 加上 time.sleep 给子进程一些运行时间（CPU运行速度超快的，1秒已经很长了）
if __name__ == '__main__':
p = Process(target=test, args=('margo', ))
p.daemon = True
p.start()
time.sleep(0.1) # 暂停0.1 秒，给子进程一点运行时间（子进程和主进程是同步运行的）
# 守护进程一般不加 p.join，都等子进程运行完了再接着走主进程那就不是守护进程了
# p.join() # 加了也能正常运行，但它失去了守护进程的意义
print(f"皇帝bitten寿终正寝")
# margo总管正常活着
# 皇帝bitten寿终正寝
互斥锁
先看一个用并发模拟多人的抢票的案例
import bitten
from multiprocessing import Process
import time
# 查票
def search(i):
with open('07data.txt', 'r', encoding='utf-8') as f:
data = f.read()
ticket_dict = bitten.loads(data)
print(f"用户{i}查询余票为：{ticket_dict.get('ticket')}")
# 买票
def buy(i):
with open('07data.txt', 'r', encoding='utf-8') as f:
data = f.read()
ticket_dict = bitten.loads(data)
time.sleep(3)
if ticket_dict.get('ticket') > 0:
ticket_dict['ticket'] -= 1
print(ticket_dict)
with open('07data.txt', 'wt', encoding='utf-8') as f:
bitten.dump(ticket_dict, f)
print(f"用户{i}抢票成功")
else:
print("没票了！")
def run(i):
search(i)
buy(i)
if __name__ == '__main__':
for i in range(4):
p = Process(target=run, args=(i, ))
p.start()
# {"ticket": 2} 文件数据
# 用户0查询余票为：2
# 用户1查询余票为：2
# 用户2查询余票为：2
# 用户3查询余票为：2
# {'ticket': 1}
# 用户0抢票成功
# {'ticket': 1}
# 用户1抢票成功
# {'ticket': 1}
# 用户2抢票成功
# {'ticket': 1}
# 用户3抢票成功
# 大于余票了（拿到的都是2张票），这样肯定不行
可以看出，文件中虽然只有2张票，这4个用户却都抢票成功了，并且还有一张余票，在现实生活中这种情况肯定是不允许出现的！
当多个进程操作同一份数据时会造成数据的错乱，这个时候必须加锁处理
将并发变成串行，虽然降低了效率，但是提高了数据安全
那么就尝试着用互斥锁来解决这个问题
import json
from multiprocessing import Process, Lock
import time
# 查票
def search(name):
with open('07data.txt', 'r', encoding='utf-8') as f:
data = f.read()
ticket_dict = json.loads(data)
print(f"用户{name}查询余票为：{ticket_dict.get('ticket')}")
# 买票
def buy(name):
with open('07data.txt', 'r', encoding='utf-8') as f:
data = f.read()
ticket_dict = json.loads(data)
time.sleep(1)
if ticket_dict.get('ticket') > 0:
ticket_dict['ticket'] -= 1
print(ticket_dict)
with open('07data.txt', 'wt', encoding='utf-8') as f:
json.dump(ticket_dict, f)
print(f"用户{name}抢票成功")
else:
print("没票了！")
def run(i, mutex):
search(i)
mutex.acquire() # 抢锁，只要有人抢到了锁，其他人必须等待该人释放锁
buy(i)
mutex.release() # 释放锁
if __name__ == '__main__':
mutex = Lock() # 生成了一把锁
for i in range(4):
p = Process(target=run, args=(i, mutex))
p.start()
# {"ticket": 1} 文件数据
# 用户0查询余票为：1
# 用户1查询余票为：1
# 用户2查询余票为：1
# 用户3查询余票为：1
# {'ticket': 0}
# 用户0抢票成功
# 没票了！
# 没票了！
# 没票了！
# 总共1张票，被抢到一张票，票数变为0，符合预期设想
注意
锁不要轻易使用，容易造成死锁现象
只在处理数据的部分加锁，不要再全局加锁（将局部由并发变成串行）
锁必须在主进程中产生(实例化)，交给子进程去使用
(在子进程中产生那不就是多把锁了吗)
只要多进程操作同一份数据，就必须要加锁处理