'''
进程理论
程序：一堆代码
进程：正在运行的程序
进程是一个实体。每一个进程都有它自己独立的内存空间
同步和异步：针对任务的提交方式
同步：提交任务之后原地等待任务的返回结果，期间不做任何事
异步：提交任务后，不等待任务的返回结果，执行运行下一行代码
阻塞与非阻塞：针对程序运行的状态
阻塞：遇到io操作 》》阻塞态
非阻塞：就绪或者运行态 》》就绪态，运行态
1 进程理论
2 开启进程的两种方式 （***）
p.start(): 启动进程，并调用该进程中的p.run()
1
from multiprocessing import Process
import time
def task(name):
print('%s is running'%name)
time.sleep(3)
print('%s is over'%name)
注意，在windows系统中，创建进程会将代码以模块的方式从头到尾加载一遍
#一定要写在 if __name__ == '__main__': 代码块里面
强调：函数名一旦加括号，执行优先级最高，立刻执行
if __name__ == '__main__':
p1=Process(target=task,args=('egon',)) # 这一句话只是实例化了一个Process对象
p1.start() #告诉操作系统创建一个进程
print('主')
2
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self,name):
super().__init__()
self.name=name
#必须写run方法
def run(self):
print('%s is running' %self.name)
time.sleep(1)
print('%s is end'%self.name)
if __name__ == '__main__':
obj =MyProcess('egon')
obj.start()
print('主')
3 进程对象的join方法 （***）
join 的作用仅仅只是让主进程等待子进程的结束,不会影响子进程的运行
join(0.1) 让主进程等待子进程0.1秒 等待0.1秒后就不再等了
4 进程之间内存隔离 （***）
#记住 进程与进程之间数据是隔离的！！！
from multiprocessing import Process
x=100
def task():
global x
x=1
if __name__ == '__main__':
p =Process(target =task)
p.start() #在当前进程中启动子进程 异步 只是告诉操作系统启动子进程指令（系统命令，没有代码读取速度快）
p.join() #同步 等待子进程运行结束 才会继续执行下面的代码
print('主',x)
5 进程对象其它相关方法
p1.terminate() #杀死子进程 异步 发给系统命令不等待
time.sleep(0.1) #给系统一个反应时间
print(p1.is_alive()) #判断子进程是否存活
from multiprocessing import Process,current_process
current_process.pid() 子进程的进程id号
import os
os.getpid() 子进程端口号
os.getppid() 父进程的端口号 父进程还可以查看父进程 查看的是运行这个py文件的程序端口号
6 僵尸进程与孤儿进程
两种情况下会回收子进程的pid等信息
1 父进程正常结束
2 join方法
孤儿进程：父进程意外死亡
linux下
init孤儿福利院：用来回收孤儿进程所占用的资源
ps aux |grep 'Z'
7 守护进程
p.daemon:默认值为False,如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True
后，p不能创建自己的新进程，必须在p.start()之前设置
form multiprocessing import Process
import time
def task(name):
print('%s 正活着'%name)
time.sleep(3)
print('%s 正常死亡' %name)
if __name__ == '__main__':
p=Process(target=task,args=('egon总管',))
p.daemon =True #必须在p.start 开启进程命令之前声明
p.start()
print('皇帝jason正在死亡')
父进程死亡 子进程必须死
8 互斥锁 （***） 锁千万不要随意去用
牺牲了效率但是保证了数据的安全
锁一定要在主进程中创建，给子进程去用
解决多个进程操作同一份数据，造成数据不安全的情况
加锁会将并发变成串行
锁通常用在对数据操作的部分，并不是对进程全程加锁
mutex.acquire() #抢锁 一把锁不能同时被对个人使用，没有抢到的人，就一直等待锁释放
buy(i)
mutex.release() #释放锁
9 进程间通信》》》 IPC机制
10 生产者消费者模型 （***）
'''
创建进程的方式1：
from multiprocessing import Process
import time
def task(name):
print('%s is running'%name)
time.sleep(3)
print('%s is over'%name)
if __name__ == '__main__':
p1=Process(target=task,args=('egon',)) #这一句话只是实例化了一个Process对象
p1.start() #告诉操作系统创建一个进程
print('主')
主
egon is running
egon is over
创建进程2
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self,name):
super().__init__()
self.name=name
#必须写run方法
def run(self):
print('%s is running'%self.name)
time.sleep(1)
print('%s is end'%self.name)
if __name__ == '__main__':
obj=MyProcess('egon')
obj.start()
print('主')
主
egon is running
egon is end
join 方法
from multiprocessing import Process
import time
def task(name,n):
print('%s is running'%name)
time.sleep(n)
print('%s is over'%name)
if __name__ == '__main__':
start_time=time.time()
p_list=[]
for i in range(1,4):
p=Process(target=task,args=('子进程%s'%i,i))
p.start()
p_list.append(p)
for i in p_list:
i.join() #主进程等待子进程结束，才能继续运行 最后一个需要等待3秒可以把前两个子进程都运行完(并行）
# p1=Process(target=task,args=('egon',1))
# start_time=time.time()
# p1.start() #千万要知道，这句话只是告诉操作系统需要进程 由系统分配创建进程
# p1.join() #主进程等待子进程结束 才继续运行
#
# egon is running
# egon is over
# 主
# 1.1000628471374512
print('主',time.time()-start_time)
#join的作用仅仅只是让主进程等待子进程的结束，不会影响子进程的运行
#随机的一次
子进程2 is running
子进程3 is running
子进程1 is running
子进程1 is over
子进程2 is over
子进程3 is over
主
3.1401796340942383
# 4 进程间数据隔离
from multiprocessing import Process
x =100 #主进程
def task():
global x
x =1 #子进程
if __name__ == '__main__':
p=Process(target=task)
p.start()
p.join()
print('主',x)
主 100
进程与进程之间数据是隔离的
# 5 进程对象其他相关方法
from multiprocessing import Process,current_process
import time
def task():
print('%s is running'%current_process().pid)
time.sleep(3)
print('%s is over'%current_process().pid)
# if __name__ == '__main__':
# p1=Process(target=task)
# p1.start()
# print('主')
# 主
# 5660 is running
# 5660 is over
# if __name__ == '__main__':
# p1=Process(target=task)
# p1.start()
# p1.terminate() #杀死子进程的指令 代码读取速度比系统块 如果没有睡眠等待时间
# print(p1.is_alive()) #判断子进程是否存活
# print('主')
#
# True
# 主
if __name__ == '__main__':
p1=Process(target=task)
p1.start()
p1.terminate() #杀死子进程的指令 代码读取速度比系统块 如果没有睡眠等待时间
time.sleep(0.1)
print(p1.is_alive()) #判断子进程是否存活
print('主')
False
主
# 守护进程
from multiprocessing import Process
import time
def task(name):
print('%s 正活着'%name)
time.sleep(1)
print('%s 正常死亡'%name)
if __name__ == '__main__':
p=Process(target=task,args=('egon总管',))
p.daemon=True #必须在p.start开启进程命令之前声明
p.start() #异步 不等待子进程
# p.daemon = True #写在后面会报错
print('皇帝jaso正在死亡')
皇帝jaso正在死亡 #父进程结束，子进程也结束
互斥锁
from multiprocessing import Process,Lock
import json
import time
import random
def search(i):
with open('info','r',encoding='utf-8')as f:
data =json.load(f)
print('用户%s查询余票数：%s'%(i,data.get('ticket')))
def buy(i):
#买票之前害的先查有没有票
with open('info','r',encoding='utf-8')as f:
data=json.load(f)
time.sleep(random.randint(1,3)) #模拟网络延迟
if data.get('ticket') >0:
data['ticket'] -=1 #买票
with open('info','w',encoding='utf-8')as f:
json.dump(data,f)
print('用户%s抢票成功'%i)
else:
print('用户%s查询余票为0'%i)
def run(i,mutex):
search(i)
mutex.acquire() #抢锁 一把锁不能同时被多个人使用，没有抢到的人，就一直等待锁释放
buy(i)
mutex.acquire() #释放锁
if __name__ == '__main__':
mutex=Lock()
for i in range(1,11):
p=Process(target=run,args=(i,mutex))
p.start()
用户1查询余票数：1
用户3查询余票数：1
用户9查询余票数：1
用户4查询余票数：1
用户7查询余票数：1
用户8查询余票数：1
用户5查询余票数：1
用户2查询余票数：1
用户6查询余票数：1
用户10查询余票数：1
用户1抢票成功