标签：不能 imp count 本质 下载 创建 空间 通讯 odi
# 1.守护进程 1个进程b 他的守护进程a 在被守护进程b死亡的时候a已死亡
# 应用场景 在运行的qq过程中,开启了一个进程 用于下载文件 然而文件还没有下完qq就退出了 下载任务也应该跟随qq的退出而结束
# import time
# from multiprocessing import Process,Lock
#
#
#
# def task():
# print(‘妃子的一生‘)
# time.sleep(5)
# print(‘妃子凉凉了‘)
#
#
# if __name__ == ‘__main__‘:
# fz = Process(target=task)
# fz.daemon = True
# fz.start()
# print(‘皇帝登基了‘)
# time.sleep(2)
# print(‘当了10年皇帝‘)
# print(‘皇帝驾崩了‘)
# 2.互斥锁
# 当多个进程共享数据时候时,可能会造成数据错乱
# 1.使用join ,来让这些进程串行 但是这将造成无法并发,进程执行任务的顺序就固定了.
# 2.使用同一把锁 将需要共享的数据加锁 其他进程在访问数据的时候 那就必须等待当前进程使用完毕
# 锁的本质 就是一个bool类型的数据,在执行代码前会先判断这个值
#必须保证锁是同一把
#锁的实现原理伪代码:
#
# l=False
#
# def task4(lock):
# global l
# if l == False:
# l=True
# print(‘my name is 2‘)
# time.sleep(random.randint(1,2))
# print(‘my age is 19‘)
# l=False
#
#
#
#
#
#
#
#
# import random
# import time
#
#
# def task1(lock):
# lock.acquire() # 是一个阻塞函数 会等到别的进程释放锁时才能继续执行
# print(‘my name is 1‘)
# time.sleep(random.randint(1,2))
# print(‘my age is 18‘)
# lock.release()
#
# def task2(lock):
# lock.acquire()
# print(‘my name is 2‘)
# time.sleep(random.randint(1,2))
# print(‘my age is 19‘)
# lock.release()
#
# def task3(lock):
# lock.acquire()
# print(‘my name is 3‘)
# time.sleep(random.randint(1,2))
# print(‘my age is 20‘)
# lock.release()
#
# if __name__ == ‘__main__‘:
# lock=Lock()
# p1 = Process(target=task1,args=(lock,))
# p1.start()
# p2 = Process(target=task2,args=(lock,))
# p2.start()
# p3 = Process(target=task3,args=(lock,))
# p3.start()
#多个任务在共享一个数据 串行效率低 但是不会出现问题 并发效率高但是数据可能错乱
#模拟抢票
# import json,time,random
# from multiprocessing import Process,Lock
# def check_ticket(usr):
# with open("ticket.json",‘r‘,encoding=‘utf-8‘) as f:
# dic =json.load(f)
# print(‘%s查看剩余票数%s‘%(usr,dic[‘count‘]))
#
# def buy_ticket(usr):
# with open("ticket.json",‘r‘,encoding=‘utf-8‘) as f:
# dic =json.load(f)
# if dic[‘count‘] > 0:
# time.sleep(random.randint(1,2))
# dic[‘count‘]-=1
# with open(‘ticket.json‘,‘w‘,encoding=‘utf-8‘)as f2:
# json.dump(dic,f2)
# print(‘%s购买成功!‘%usr)
#
#
# def task(usr,lock):
# check_ticket(usr)
# lock.acquire()
# buy_ticket(usr)
# lock.release()
# if __name__ == ‘__main__‘:
# lock = Lock()
#
#
# for i in range(5):
# p=Process(target=task,args=(‘用户%s‘%i,lock))
# p.start() #首先全部并发查看票,然后买票的时候串行
#join 和锁的区别
# 1.join中的顺序是固定的 不公平
# 2.join是完全串行 而锁可以让部门代码串行,其他代码并发
# #Lock 和 Rlock的区别
# from multiprocessing import RLock
# # 1.在lock下 如果在执行代码前添加了2次lock.acquire() ,代码将无法执行
# lock = Lock()
# lock.acquire()
# lock.acquire()
# print(‘哈哈‘)
# lock.release()
# # 2.在Rlock模式下 如果在执行代码前添加无数次lock.acquire(),代码都可以运行. 表示重入锁 可以多次执行acquire
#
# lock = RLock()
# lock.acquire()
# lock.acquire()
# print(‘哈哈‘)
# lock.release()
#
#
#
#
#
# import time
#
# def task5(i):
# lock.acquire()
# lock.acquire()
# print(i)
# time.sleep(3)
# lock.release()
#
# if __name__ == ‘__main__‘:
# lock = RLock
# p1 = Process(target=task5,args=(1,lock))
# p1.start()
# p2 = Process(target=task5,args=(2,lock))
# p2.start()
# 当RLock存在2个进程进行竞争的时候 :
# 当只有一次acquire的时候也可以起到锁的作用;在代码中即为先打印了1之后过3秒再打印2
# 如果增加了一次acquire的执行次数而不添加release的次数,将会阻塞在第二个acquire, 即只打印出1,2不打印
# ipc进程间的通讯
# 三种方式:
# 1. 使用共享文件,过个进程同时读写一个文件
# i/o速度慢,传输大小不受限制
# 2.管道 是基于内存的速度快 但是是单向的 用起来麻烦
# 3.申请共享内存空间,多个进程可以共享这个内存区域,速度快 但是数据量不能太大
from multiprocessing import Manager,Process
def work(d):
d[‘count‘]-=1
if __name__ == ‘__main__‘:
# 开启了一个Manager共享内存
with Manager() as m:
dic = m.dict({‘count‘:2}) #在这个空间中存储了一个字典
p_l = []
for i in range(2):
p=Process(target=work,args=(dic,))
p_l.append(p)
p.start() #就绪状态
for p in p_l:
p.join()
print(dic)
#相当于给子进程进行了串行
#队列: 不止用于进程之间的通讯 先进先出
from multiprocessing import Queue
q = Queue(1) #创建1个队列 最多可以存一个数据
q.put(‘a‘) #将a装入到队列中
q.put(‘b‘,False) #程序阻塞 put默认阻塞 当容器里面装满继续装就会阻塞住
# 2.put中如果第二个参数设置为False 表示不会阻塞无论容器是否塞满,都会强行塞,如果满了就抛异常
print(q.get()) #取出一个数据a
print(q.get()) #没有添加数据第二次取无数据就阻塞 默认阻塞
# 如果get中参数设为False 也是非阻塞,当取完了还要去取就报错
# 其中还有个参数timeout= 设置为3的时候表示 当阻塞状态下3秒还没有拿到数据会报错
标签：不能 imp count 本质 下载 创建 空间 通讯 odi
原文地址：https://www.cnblogs.com/fanbiyong/p/10197551.html
