进程的互斥锁和消息队列

守护进程

from multiprocessing import Process
import time
​
def eat(name):
    for i in range(5):
        print(f'{name}在吃第{i}碗鸡汤')
        time.sleep(1)
​
if __name__ == '__main__':
​
    p = Process(target=eat , args=('小奕',))
    # daemon 当主进程结束的时候 ， 也立刻结束掉子进程的程序
    p.daemon = True
    p.start()
    time.sleep(3)
    print('进程结束')

互斥锁

进程与进程之间的数据是不共享 ， 可以使用文件共享数据实现进行之间的通信。当数据共享就会有竞争，竞争带来的问题就是数据错乱。

from multiprocessing import Process
import time
import json
​
def search(name):
    time.sleep(1)
    dic = json.load(open('db.txt' , 'r' , encoding='utf-8'))
    print(f'{name}正在查看票源 ， 当前剩余票数为{dic["count"]}')
​
def get(name):
    dic = json.load(open('db.txt', 'r', encoding='utf-8'))
    if dic["count"] > 0:
        dic["count"] -= 1
        time.sleep(2)
        json.dump(dic , open('db.txt', 'w', encoding='utf-8'))
        print(f'{name}购票成功')
​
def func(name):
    search(name)
    get(name)
​
if __name__ == '__main__':
    for i in range(1 , 6):
        p = Process(target=func , args=(f'Tom{i}号',))
        p.start()

互斥锁：就是多个进程在访问同一个资源，加上互斥锁把并发成串行，可以保证数据的安全不会错乱；但是效率比较低。

加锁处理：以牺牲效率的情况 ，来保证数据的安全

from multiprocessing import Process , Lock
import time
import json
​
def search(name):
    time.sleep(1)
    dic = json.load(open('db.txt' , 'r' , encoding='utf-8'))
    print(f'{name}正在查看票源 ， 当前剩余票数为{dic["count"]}')
​
def get(name):
    dic = json.load(open('db.txt', 'r', encoding='utf-8'))
    if dic["count"] > 0:
        dic["count"] -= 1
        time.sleep(2)
        json.dump(dic , open('db.txt', 'w', encoding='utf-8'))
        print(f'{name}购票成功')
    else:
        print(f'{name}购票不成功')
​
def func(name , l):
    search(name)
    # 加锁
    l.acquire()
    get(name)
    # 解锁
    l.release()
​
if __name__ == '__main__':
    # 创建锁
    l = Lock()
    for i in range(1 , 6):
        p = Process(target=func , args=(f'Tom{i}号',l))
        p.start()

from multiprocessing import Process , Lock
import time
import json
​
def search(name):
    time.sleep(1)
    dic = json.load(open('db.txt' , 'r' , encoding='utf-8'))
    print(f'{name}正在查看票源 ， 当前剩余票数为{dic["count"]}')
​
def get(name):
    dic = json.load(open('db.txt', 'r', encoding='utf-8'))
    if dic["count"] > 0:
        dic["count"] -= 1
        time.sleep(2)
        json.dump(dic , open('db.txt', 'w', encoding='utf-8'))
        print(f'{name}购票成功')
    else:
        print(f'{name}购票不成功')
​
def func(name , l):
    search(name)
    # 加锁
    l.acquire()
    get(name)
    # 解锁
    l.release()
​
if __name__ == '__main__':
    # 创建锁
    l = Lock()
    for i in range(1 , 6):
        p = Process(target=func , args=(f'Tom{i}号',l))
        p.start()
        p.join()

信号量

信号量也是一把锁

互斥锁是同一时间是只有一个任务能抢到锁

信号量同一时间可以有多个任务拿到锁

from multiprocessing import Process , Semaphore
import time
​
​
def black_room(name,s):
    s.acquire()
    print(f'{name}猥琐的溜进小黑屋')
    time.sleep(3)
    print(f'{name}惊恐的跑出房间')
    s.release()
​
if __name__ == '__main__':
    # 设置信号量 ， 设置有多少个锁
    s = Semaphore(3)
    for i in range(10):
        p = Process(target=black_room , args=(f'张三{i}号',s))
        p.start()

进程通信

进程通信：消息队列

消息队列的使用：在内存中建立队列模型 ， 进程通过队列将消息存入 ， 或者从队列取出完成进程通信

from multiprocessing import Queue , Process
import time
​
def write(q):
    # 将数据写入到queue消息队列中
    ls = ['武则天','孙悟空','李白','孙尚香','亚瑟','鲁班']
    for i in ls:
        q.put(i)
        print(f'queue获取到值：{i}')
        time.sleep(2)
​
def read(q):
    # 从消息队列中获取数据
    while True:
        # 判断消息队列总消息是否为空
        if not q.empty():
            value = q.get(True)
            print(f'从消息队列中获取到值：{value}')
            time.sleep(3)
        else:
            break
​
​
if __name__ == '__main__':
    q = Queue()
    w = Process(target=write,args=(q , ))
    r = Process(target=read , args=(q,))
    w.start()
    w.join()
    r.start()
    r.join()
    print('数据读取完毕')

进程类

from multiprocessing import Queue , Process
import time
​
def write(q):
    # 将数据写入到queue消息队列中
    ls = ['武则天','孙悟空','李白','孙尚香','亚瑟','鲁班']
    for i in ls:
        q.put(i)
        print(f'queue获取到值：{i}')
        time.sleep(2)
​
def read(q):
    # 从消息队列中获取数据
    while True:
        # 判断消息队列总消息是否为空
        if not q.empty():
            value = q.get(True)
            print(f'从消息队列中获取到值：{value}')
            time.sleep(3)
        else:
            break
​
​
if __name__ == '__main__':
    q = Queue()
    w = Process(target=write,args=(q , ))
    r = Process(target=read , args=(q,))
    w.start()
    w.join()
    r.start()
    r.join()
    print('数据读取完毕')