Python多进程同步Lock、Semaphore、Event实例

同步的方法基本与多线程相同。

1) Lock

当多个进程需要访问共享资源的时候，Lock可以用来避免访问的冲突。

import multiprocessing

import sys

def worker_with(lock, f):

    with lock:

        fs = open(f,"a+")

        fs.write('Lock acquired via with\n')

        fs.close()

        

def worker_no_with(lock, f):

    lock.acquire()

    try:

        fs = open(f,"a+")

        fs.write('Lock acquired directly\n')

        fs.close()

    finally:

        lock.release()
if __name__ == "__main__":
    f = "file.txt"

  

    lock = multiprocessing.Lock()

    w = multiprocessing.Process(target=worker_with, args=(lock, f))

    nw = multiprocessing.Process(target=worker_no_with, args=(lock, f))
    w.start()

    nw.start()
    w.join()

    nw.join()

在上面的例子中，如果两个进程没有使用lock来同步,则他们对同一个文件的写操作可能会出现混乱。

2）Semaphore

Semaphore用来控制对共享资源的访问数量，例如池的最大连接数。

import multiprocessing

import time

def worker(s,i):

    s.acquire()

    print(multiprocessing.current_process().name + " acquire")

    time.sleep(i)

    print(multiprocessing.current_process().name + " release")

    s.release()
if __name__ == "__main__":

  

    s = multiprocessing.Semaphore(2)

    for i in range(5):

        p = multiprocessing.Process(target=worker, args=(s,i*2))

        p.start()

上面的实例中使用semaphore限制了最多有2个进程同时执行。

3）Event

Event用来实现进程间同步通信。

import multiprocessing

import time

def wait_for_event(e):

    """Wait for the event to be set before doing anything"""

    print ('wait_for_event: starting')

    e.wait()

    print ('wait_for_event: e.is_set()->' + str(e.is_set()))
def wait_for_event_timeout(e, t):

    """Wait t seconds and then timeout"""

    print ('wait_for_event_timeout: starting')

    e.wait(t)

    print ('wait_for_event_timeout: e.is_set()->' + str(e.is_set()))


if __name__ == '__main__':

    e = multiprocessing.Event()

    w1 = multiprocessing.Process(name='block', 

                                 target=wait_for_event,

                                 args=(e,))

    w1.start()
    w2 = multiprocessing.Process(name='non-block', 

                                 target=wait_for_event_timeout, 

                                 args=(e, 2))

    w2.start()
    time.sleep(3)

    e.set()

    print ('main: event is set')

    

#the output is:

#wait_for_event_timeout: starting

#wait_for_event: starting

#wait_for_event_timeout: e.is_set()->False

#main: event is set

#wait_for_event: e.is_set()->True