同步与异步
表达任务的提交方式
同步：
提交完任务之后会在原地等待任务的返回结果，在等待的过程不会做任何事。
异步：
提交完任务之后 不原地等待，去干别的事情，有结果自动通知。
阻塞与非阻塞
任务的执行状态
阻塞态
进程的三状态中的阻塞态。任务有IO操作时就会进入
非阻塞态
就绪态和运行态
"""
如果想要提高程序被执行效率
就要程序一直处于就绪态和运行态
"""
同步异步和阻塞费阻塞结合使用
同步异步：用来描述任务的提交方式
阻塞非阻塞： 用来描述任务的执行状态
同步+阻塞：
银行排队办理业务，期间不做任何事，就等着
同步+非阻塞：
银行排队办理业务，期间可以去做一些其他的事，但是人还在办理业务的队列中
异步阻塞：
在椅子上坐着，不做任何事
异步非阻塞：
在椅子上面坐着，在期间喝水、吃东西、工作、玩手机、、(这个过程就是把程序运行到了极致)
创建进程的多种方式
我们常用的就是直接双击软件图标。
但是python代码也给我们提供了创建进程的方式
multiprocessing 模块
import time
from multiprocessing import Process
第一种方法：
def task(name):
print('子程序开始', name)
time.sleep(3)
print('子程序结束', name)
if __name__ == '__main__':
p1 = Process(target=task, args=('tank',))
p1.start() # 异步
task() # 同步
print('这是主程序')
===================================================================================
第二种方法：
class MyProcess(Process):
import time
from multiprocessing import Process
class MyProcess(Process):
def __init__(self,name,age):
super().__init__()
self.name = name
self.age = age
def run(self):
print('子程序开始',self.name)
time.sleep(3)
print('子程序结束',self.age)
if __name__ == '__main__':
obj = MyProcess('tank',28)
obj.start()
print('主程序')
进程间的数据隔离
一台计算机上的多个进程 数据在默认情况下是无法访问的。也称为物理隔离，但是我们也可以通过 global 来修改 外部数据实现
from multiprocessing import Process
import time
name = '呆子'
def task():
global name
name = 'tank'
print('子进程的task函数查看name', name)
if __name__ == '__main__':
p1 = Process(target=task)
p1.start() # 创建子进程
time.sleep(3) # 主进程代码等待3秒
print(name) # 主进程代码打印name
"在子程序中复制了同样的代码形成了一个新的内存空间，在此内存空间的task函数类利用global修改了外部name的值"
"""
在不同的操作系统中创建进程底层原理不一样
windows
以导入模块的形式创建进程
linux/mac
以拷贝代码的形式创建进程
"""
进程的join方法
"join方法就是让主进程等待子进程代码运行完毕之后 再执行后续的代码"
from multiprocessing import Process
import time
def task(name,username,n):
print(f'子进程的{name}开始打{username}')
time.sleep(n)
print(f'子进程的{username}被打{name}打进了医院')
if __name__ == '__main__':
p1 = Process(target = task, args = ('李晓健','周衍根',2))
p2 = Process(target = task, args = ('李晓健','周衍根',2))
start_time = time.time()
p1.start()
p1.join() # 等待p1 子进程执行完毕后在执行下面的代码
p2.start()
p2.join()
print(time.time() - start_time)
想要p1.start()之后的代码， 等待子进程全部运行结束之后再打印
1.直接sleep，但是这个方法肯定不可行，因为子进程运行时间不可控
2.join方法
针对多个子进程的等待
IPC机制与消息队列
IPC : 进程间相互通信
消息队列：存储数据的地方，谁都能存，谁都能取
Queue
from multiprocessing import Process,Queue
import time
def start(q):
q.put('我是子进程1，我往消息队列里添加了 “我是你哥”')
def end(q):
time.sleep(3)
print(f'子进程2获取数据',q.get(),q.get())
if __name__ == '__main__':
q = Queue() # 括号内可以设置存放消息的数量
# 主进程也可以往队列里添加数据
q.put('我是你们的父亲')
p1 = Process(target=start,args=(q,))
p2 = Process(target=end,args = (q,))
p1.start()
p2.start()
----------------------------------------
子进程2获取数据 我是你们的父亲 我是子进程1，我往消息队列里添加了 “我是你哥”
----------------------------------------
# 可以看出 消息队列先进先出的规则。
生产者消费者模型
我们的代码里都有生产者与消费者
生产者：
负责产生数据
消费者：
负责处理数据
该模型除了有生产者和消费者之外还必须有消息队列(只要是能够提供数据保存服务和提取服务的理论上都可以)
eg: 文件， TXT ，数据库
进程对象的多种方法
1.查看进程号：
current_process() # 查看父进程号
current_process().pid # 查看子进程号
os查看进程号：
import os
os.getpid() # 查看子进程号
os.getppid() # 查看父进程号
代码：
def start():
print(f'我是子进程1我的进程号：', os.getpid())
print(f'我是子进程1我的父进程号：', os.getppid())
def end():
print(f'我是子进程2我的进程号：', os.getpid())
print(f'我是子进程2我的父进程号：', os.getppid())
if __name__ == '__main__':
p1 = Process(target=start)
p2 = Process(target=end)
p1.start()
p2.start()
----------------------------------------
我是子进程1我的进程号： 45084
我是子进程2我的进程号： 22744
我是子进程1我的父进程号： 28576
我是子进程2我的父进程号： 28576
----------------------------------------
===================================================================================
2.中止进程：
p1.terminate()
代码：
def start():
print(f'我是子进程1')
def end():
print(f'我是子进程2')
if __name__ == '__main__':
p1 = Process(target=start)
p2 = Process(target=end)
p1.start()
p1.terminate()
print('我p1被杀死了')
p2.start()
----------------------------------------
我p1被杀死了
我是子进程2
----------------------------------------
===================================================================================
3.判断进程是否存活
p1.is_alive() # 判断过程中会经历主进程回收，如果中间不加 sleep 还是 为True 还没死透，也称为假死
4.start() # 创建子进程
5.join() # 等待子进程代码执行完毕后在执行主进程代码
守护进程
守护进程会随着守护的 进程结束(主进程)而立刻结束
p.daemon = True
from multiprocessing import Process
import time
def task(name):
print(f'御用特使:{name}还没死')
time.sleep(3)
print(f'御用特使:{name}死了')
if __name__ == '__main__':
p = Process(target=task, args=('黑大帅', ))
# start_time = time.time()
p.daemon = True # 将子进程设置为守护进程，主进程结束，子进程立即结束
p.start()
time.sleep(1)
# end_time = time.time() - start_time
print(f'我活了{end_time}')
print('皇上毙了')
print('我黑子也得死')
# p.daemon = True 一定要放在p.start()上面
----------------------------------------
御用特使:黑大帅还没死
我活了1.0227680206298828
皇上毙了
我黑子也得死
----------------------------------------
僵尸进程和孤儿进程
僵尸进程
所有的子进程在运行结束之后都会变成僵尸进程(死了没死透)
因为还保留着pid和一些运行过程的中的记录便于主进程查看(只是短时间保存)
等这些信息被主进程回收,就彻底死了
1.主进程正常结束
2.调用join方法 等待子进程 死透
# 僵尸进程是无害的
孤儿进程
# 子进程存在，但是父进程毙了
子进程会被操作系统自动接管 （类似于福利院收养了）
多进程数据错乱问题
import json
from multiprocessing import Process
import time
import random
# 设置票数，一张 是个文件
ticket_data.json : {"ticket_num": 1}
# 查票功能
def search(name):
with open(r'ticket_data.json', 'r', encoding='utf8') as f:
data = json.load(f)
print(f'{name}查询余票为:%s'% data.get('ticket_num'))
# 买票功能
def buy(name):
# 先查一下票数
with open(r'ticket_data.json', 'r', encoding='utf8') as f:
data = json.load(f)
time.sleep(random.randint(1, 3)) # 停留1~3秒
# 判断
if data.get('ticket_num') > 0:
data['ticket_num'] -= 1
with open(r'ticket_data.json', 'w', encoding='utf8') as f:
json.dump(data, f)
print(f'{name}抢票成功')
else:
print(f'{name}抢票失败，票已经没了')
# 将买票封装成函数
def run(name):
search(name)
buy(name)
# 模拟多人同时
if __name__ == '__main__':
for i in range(1, 6):
p = Process(target=run, args=('用户:%s' % i, ))
p.start()
用户:1查询余票为:1
用户:3查询余票为:1
用户:2查询余票为:1
用户:4查询余票为:1
用户:5查询余票为:1
用户:1抢票成功
用户:2抢票成功
用户:5抢票成功
用户:3抢票成功
用户:4抢票成功
# 结果很明显，是错乱的，而且都5个人买一张都成功了
"""
在多个进程操作同一个数据的时候会造成数据的错乱， 所以我们需要增加一个加锁处理(互斥锁)
将并发变成串行， 效率低了，但安全性高了
互斥锁并不能轻易使用， 容易造成死锁现象
互斥锁旨在处理数据的部分加锁， 不能什么地方都加
"""
加上互斥锁
# 增加互斥锁
from multiprocessing import Process, Lock
mutex = Lock()
mutex.acquire() # 上锁
mutex.release() # 解锁
# 将买票封装成函数
def run(name,mutex):
search(name)
mutex.acquire() # 上锁
buy(name)
mutex.release() # 解锁
# 模拟多人同时
if __name__ == '__main__':
mutex = Lock()
for i in range(1, 6):
p = Process(target=run, args=('用户:%s' % i, mutex))
p.start()
用户:1查询余票为:1
用户:2查询余票为:1
用户:3查询余票为:1
用户:4查询余票为:1
用户:5查询余票为:1
用户:1抢票成功
用户:2抢票失败，票已经没了
用户:3抢票失败，票已经没了
用户:4抢票失败，票已经没了
用户:5抢票失败，票已经没了
"""
行锁: 针对行数加锁， 同一时间只能一个人操作
表锁: 针对表数据加锁， 同一时间只能一个人操作
"""
