同步和互斥

同步和互斥：

目的：对共有资源的操作会产生争夺，同步互斥是一种解决争夺的方案

临界资源：多个进程或者线程都可以操作的资源

临界区：操作临界资源的代码段

同步；同步是一种合作关系，为完成某种多进程或多线程之间形成一种协调，按照条件次序执行，传递告知资源情况。这种协调可能因为阻塞关系达成的

 

 

互斥：互斥是一种制约关系，当一个进程或线程进入到临界区会进行加锁操作，此时其他进程

（线程）在企图操作临界资源就会阻塞。只有当资源被释放才能进行操作。

 

 

 

Event事件

创建 事件对象

e=Event()

 

提供事件阻塞

e,wait()

e.wait(time) 等待 time 时间后，执行下一步。或者在调用 e.set() 后立即执行下一步

 

对事件对象进行设置，此时wait判断，如果事件被set,则结束阻塞

e.set()

 

清除对该事件对象的set

e.clear()

 

检测对象是否被设置，如果已经设置返回True

e.is_set()

from multiprocessing import Event,Process
from time import sleep

def wait_event():
    print("进程1我在阻塞，等待主进程")
    e.wait()
    print("主进程操作完，现在是我",e.is_set())

def wait_event_timeout():
    print("进程2我在阻塞，等待主进程")
    e.wait(2)
    print("不再等待，处理其他",e.is_set())

e=Event()
p1=Process(name='block',target=wait_event)
p2=Process(name='non_block',\
    target=wait_event_timeout)

p1.start()
p2.start()

print("主进程操作临界资源")
sleep(5)
e.set()

print("主进程操作完毕")

p1.join()
p2.join()

yangrui@ubuntu:~/num6$ python3 process_event.py 
进程1我在阻塞，等待主进程
主进程操作临界资源
进程2我在阻塞，等待主进程
不再等待，处理其他 False
主进程操作完毕
主进程操作完，现在是我 True

结果

锁 Lock

multiprocessing ----------------->lock

lock=Lock()

lock.acquire()上锁

lock.release() 解锁

with lock对象:-------->给with代码段上锁

..........

..........

          -------------->with 代码段执行结束自动解锁

=====================================================

在lock对象处于上锁状态的时候，再企图上锁，则会阻塞，直到锁被释放，才能继续执行上锁操作

======================================================

 

from multiprocessing import Process,Lock

import sys
from time import sleep

#创建LOCK对象
lock=Lock()


#sys.stdout为所有进程的共有资源
def worker1():
    lock.acquire() #上锁
    for i in range(5):
        sleep(1)
        sys.stdout.write("worker1 输出\n")
    lock.release()    #解锁

#每个进程中运行的函数，都需要有上锁和解锁的代码
def worker2():
    lock.acquire()
    for i in range(5):
        sleep(1)
        sys.stdout.write("worker2 输出\n")    
    lock.release()    

w1=Process(target=worker1)
w2=Process(target=worker2)

w1.start()
w2.start()

w1.join()
w2.join()

 

转载于:https://www.cnblogs.com/sike8/p/11149889.html