python 进程锁 生产者消费者模型 队列 (进程其他方法,守护进程,数据共享,进程隔离验证)

#######################总结#########

主要理解 锁      生产者消费者模型 解耦用的   队列

共享资源的时候 是不安全的 所以用到后面的锁

守护进程:p.daemon = True  #将该进程设置为守护进程,必须写在start之前,意思如果我的主进程代码运行结束了,你这个子进程不管运行到什么地方,都直接结束

 

######### 进程其他方法
import time
import os
from multiprocessing import Process

def f1():
    print('子进程的pid',os.getpid())
    print('aaa')
def f2():
    print('bbb')
if __name__ == '__main__':
    p1=Process(target=f1,name='宝宝1')
    p1.start()
    print(p1.name)
    print('子进程的pid',p1.pid)
    print('父进程的pid', os.getpid())
    print(p1.is_alive())#判断进程是否存活,是否还在运行
    p1.terminate()#给系统操作发一个结束信号
                  # 这里需要等待一下 因为代码执行比系统反应快
    time.sleep(1)
    print(p1.is_alive())
########################
宝宝1
子进程的pid 7352
父进程的pid 8188
True
False

验证进程隔离例子

import time
from multiprocessing import Process
global_num = 100
def func1():
    global global_num
    global_num = 0
    print('子进程全局变量>>>',global_num)
# print(global_num)会打印出2个100
if __name__ == '__main__':
    p1 = Process(target=func1,)
    p1.start()
    time.sleep(1)
    print('主进程的全局变量>>>',global_num)
#################
子进程全局变量>>> 0
主进程的全局变量>>> 100

守护进程

import time
from multiprocessing import Process

def f1():
    time.sleep(3)
    print('xxxxx')
def f2():#加这个函数 为了形成对比
    time.sleep(5)
    print('普通子进程的代码')
if __name__ == '__main__':
    p=Process(target=f1,)
    p.daemon=True#将该进程设置为守护进程,必须要在start之前
    #子进程代码不管运行到什么地方 都需要结束
    p.start()
    
    p2=Process(target=f2,)
    p2.start()
    p2.join()#加上join等待2号普通进程的结束,才继续执行下面主进程中的代码
                #就会把f1守护模式中的方法执行出来
                #因为f2设置的为5s f1为3s
    print('主进程,结束')
##############################

xxxxx
普通子进程的代码
主进程 结束

如果不加 f2 只会输出:主进程 结束

抢票程序

#创建一个ticket 文件 里面放上字典
{'count': 1}

###加锁两种方法
import time
from multiprocessing import Process,Lock

# def f1(i,lic):
#     lic.acquire()
#     time.sleep(1)
#     print(i)
#     lic.release()
#########第二种加锁写法##########################
def f1(i,lic):
    with lic:
        time.sleep(1)
        print(i)
if __name__ == '__main__':
    lic=Lock()
    for i in range(10):
        p=Process(target=f1,args=(i,lic))
        p.start()

抢票程序

import time
from multiprocessing import Process,Lock
def show_t(i):#传参i 10个人查看
    with open('ticket','r',encoding='utf-8') as f:
        ticket_data = f.read()#读取文件里的内容
    t_data = eval(ticket_data)#将里面的文件转成成字典格式
    print('%s查询剩余票数为%s'%(i,t_data['count']))
def get_t(i,l1):#传入10个人进行抢票
    # with l2:第二种写法
    l1.acquire()
        #进行加锁循环,而谁能抢到票是由操作系统决定的
    with open('ticket', 'r', encoding='utf-8') as f:
        ticket_data = f.read()
    t_data = eval(ticket_data)

    if t_data['count'] > 0:#进行判断 如果余票大于0
        t_data['count'] -= 1#就进行减1操作
        print('%s抢票成功'%i)
        time.sleep(0.2)
        with open('ticket', 'w') as f:
            f.write(str(t_data))
    else:
        print('没票了!!!')
    l1.release()
if __name__ == '__main__':
    l1 = Lock()
    for i in range(10):
        p1 = Process(target=show_t,args=(i,))
        p1.start()
    for i in range(10):
        p2 = Process(target=get_t,args=(i,l1) )
        p2.start()

####################
1查询剩余票数为1
2查询剩余票数为1
3查询剩余票数为1
7查询剩余票数为1
0查询剩余票数为1
5查询剩余票数为1
8查询剩余票数为1
6查询剩余票数为1
4查询剩余票数为1
2抢票成功
9查询剩余票数为1
没票了!!!
没票了!!!
没票了!!!
没票了!!!
没票了!!!
没票了!!!
没票了!!!
没票了!!!
没票了!!!

Process finished with exit code 0

如果没有锁  会有10个进程 进行 异步同时请求   这个顺序是由操作系统决定的  每个人都能执行到 if count>0 都执行了 -1操作,都感觉自己抢到票了,导致结果也不一样

队列 Queue

#####队列简单的解释
from multiprocessing import Process,Queue
q=Queue(3)#创建一个队列对象,长度为3 先进先出
q.put(1)
q.put(2)
q.put(3)
print('>>>',q.qsize())
print(q.full())  #q.full()了解,因为这个东西不可靠,满了返回一个True,不满返回一个False

try:
    q.put_nowait(4) #不阻塞程序,但是会报错queue.Full,可以通过捕获异常来进行其他的操作
except:
    print('队列满了,玩别的去吧')

print(q.get())
print(q.get())
print(q.get())
print('是不是空了呀:',q.empty()) #q.empty()了解,因为这个东西不可靠,空了返回一个True,不空返

try:
    q.get_nowait()  #queue.Empty
except:
    print('队列空了,搞得别的事情')
print('拿多啦')

队列简单通信

from multiprocessing import Process,Queue
def f1(q):
    q.put('约吗?')
if __name__ == '__main__':
    q=Queue(3)
    p=Process(target=f1,args=(q,))
    p.start()
    son_msg=q.get()
    print('来自子进程的消息',son_msg)

数据共享  manager

 

Joinablequeue 

　　task_done() #给队列发出一个任务处理完毕的信号

　　join()#等待放入队列中的任务全部执行完毕,也就是等待task_done()的信号数量,

　　　　　　　　　　　　　　　　　　　　　#等于放入队列中的所有任务数量 不会造成阻塞

###生产者 消费者模型
import time
from multiprocessing import Process, Queue, JoinableQueue

# 生产者
def producer(q):
    for i in range(10):
        time.sleep(0.3)
        s='包子%s号'%i
        print(s+'新鲜出炉')
        q.put(s)
    q.join()#就等着task_done()信号的数量,和我put进去的数量相同时,才继续执行
    print('所有的任务都被处理了,继续潜行吧骚年们')
def consumer(q):
    while 1:
        time.sleep(0.5)
        baozi=q.get()
        print(baozi+'被吃了')
        q.task_done()#给队列发送一个取出的这个任务已经处理完毕的信号
if __name__ == '__main__':
    q = JoinableQueue(30)  # 30长度的队列
    pro_p=Process(target=producer,args=(q,))
    con_p=Process(target=consumer,args=(q,))
    pro_p.start()
    con_p.daemon=True
    con_p.start()

    pro_p.join()
    print('主进程结束')

############################

包子0号新鲜出炉
包子0号被吃了
包子1号新鲜出炉
包子2号新鲜出炉
包子1号被吃了
包子3号新鲜出炉
包子2号被吃了
包子4号新鲜出炉
包子5号新鲜出炉
包子3号被吃了
包子6号新鲜出炉
包子7号新鲜出炉
包子4号被吃了
包子8号新鲜出炉
包子5号被吃了
包子9号新鲜出炉
包子6号被吃了
包子7号被吃了
包子8号被吃了
包子9号被吃了
所有的任务都被处理了,继续潜行吧骚年们
主进程结束