python 锁信号量事件队列

什么是python 进程锁？

#同步效率低,但是保证了数据安全重点

很多时候，我们需要在多个进程中同时写一个文件，如果不加锁机制，就会导致写文件错乱

这个时候，我们可以使用multiprocessing.Lock()

def get_ticket(i,ticket_lock):
    print("等待大家都到齐")
    time.sleep(1)
    ticket_lock.acquire()
    with open("ticket","r")as f:
        # for line in f:
            # dic=json.load(line.strip())
        dic=json.load(f)
        if dic["count"]>0:
            time.sleep(random.random())
            dic["count"]-=1
            with open("ticket","w")as s_f:
                json.dump(dic,s_f)
                print("%s号抢到票了"%i)
        else:
            print("%s号没抢到票，明年见" % i)


    ticket_lock.release()

if __name__ == '__main__':
    ticket_lock=Lock()
    for i in range(1,11):
        p=Process(target=get_ticket,args=(i,ticket_lock,))
        p.start()

抢票小模拟

什么是信号量？

# 红绿灯事件
import time
import random
from multiprocessing import Event,Process
def cars(e,i):
    if not e.is_set():
        print('car%i在等待'%i)
        e.wait()    # 阻塞 直到得到一个 事件状态变成 True 的信号
    print('33[0;32;40mcar%i通过33[0m' % i)

def light(e):
    while True:
        if e.is_set():#判断事件状态
            e.clear()
            print('33[31m红灯亮了33[0m')
        else:
            e.set()
            print('33[32m绿灯亮了33[0m')
        time.sleep(2)

if __name__ == '__main__':
    e = Event()
    traffic = Process(target=light,args=(e,))
    traffic.start()
    for i in range(20):
        car = Process(target=cars, args=(e,i))
        car.start()
        time.sleep(random.random())

红绿灯模拟

事件

# coding:utf-8

import threading
import time

event = threading.Event()


def chihuoguo(name):
  # 等待事件，进入等待阻塞状态
  print '%s 已经启动' % threading.currentThread().getName()
  print '小伙伴 %s 已经进入就餐状态！'%name
  time.sleep(1)
  event.wait()
  # 收到事件后进入运行状态
  print '%s 收到通知了.' % threading.currentThread().getName()
  print '小伙伴 %s 开始吃咯！'%name

# 设置线程组
threads = []

# 创建新线程
thread1 = threading.Thread(target=chihuoguo, args=("a", ))
thread2 = threading.Thread(target=chihuoguo, args=("b", ))

# 添加到线程组
threads.append(thread1)
threads.append(thread2)

# 开启线程
for thread in threads:
  thread.start()

time.sleep(0.1)
# 发送事件通知
print '主线程通知小伙伴开吃咯！'
event.set()

事件

Thread-1 已经启动
小伙伴 a 已经进入就餐状态！
Thread-2 已经启动
小伙伴 b 已经进入就餐状态！
主线程通知小伙伴开吃咯！
Thread-1 收到通知了.
小伙伴 a 开始吃咯！
Thread-2 收到通知了.
小伙伴 b 开始吃咯！

　队列：

import time
def girl(q):
    print(q.get())
    print(q.get())
def boy(q):
    q.put("约吗")

if __name__ == '__main__':
    q=Queue
    boy_p=Process(target=boy,args=(q,))
    girl_p=Process(target=girl,args=(q,))
    boy_p.start()
    girl_p.start()
    time.sleep(1)
    q.put("好好工作")

用队列来给进程通信

python 锁 信号量 事件 队列

python 锁信号量事件队列