multiprocessing 进程间同步说明及示例

在多进程编程中，为了避免多个进程同时访问共享资源而导致的数据不一致或者竞争问题，我们需要使用进程间同步的机制。下面是一些常用的进程间同步机制及其示例：

1. Lock 锁

Lock 锁是 Python 中最基本的同步原语，它用于控制多个进程对共享资源的访问。在使用 Lock 锁时，只有一个进程能够获取锁，其他进程需要等待锁的释放才能继续执行。下面是一个简单的 Lock 锁示例：

import multiprocessing

def worker(lock, count):
    lock.acquire()
    try:
        print('Worker {} is working'.format(count))
    finally:
        lock.release()

if __name__ == '__main__':
    lock = multiprocessing.Lock()
    workers = []
    for i in range(10):
        p = multiprocessing.Process(target=worker, args=(lock, i))
        workers.append(p)
        p.start()

在这个示例中，我们创建了 10 个进程，它们都要对 Lock 锁进行竞争。由于只有一个进程能够获取锁，因此每个进程都需要等待其他进程释放锁后才能继续执行。

2. Semaphore 信号量

Semaphore 信号量是一种更高级的同步原语，它可以控制多个进程对一个资源的访问数量。在使用 Semaphore 信号量时，我们需要指定资源的数量，每次访问资源时会将信号量减 1，如果信号量为 0，则其他进程需要等待资源的释放才能继续执行。下面是一个 Semaphore 信号量示例：

import multiprocessing

def worker(semaphore, count):
    semaphore.acquire()
    try:
        print('Worker {} is working'.format(count))
    finally:
        semaphore.release()

if __name__ == '__main__':
    semaphore = multiprocessing.Semaphore(3)
    workers = []
    for i in range(10):
        p = multiprocessing.Process(target=worker, args=(semaphore, i))
        workers.append(p)
        p.start()

在这个示例中，我们创建了 10 个进程，但是只有 3 个进程能够同时访问资源。当有一个进程访问资源时，信号量会减 1，直到信号量为 0 时，其他进程需要等待资源的释放才能继续执行。

3. Event 事件

Event 事件是一种用于多进程之间通信的同步原语，它可以让一个进程等待另一个进程的信号。在使用 Event 事件时，我们需要创建一个事件对象，当一个进程等待事件时，它会阻塞等待，直到另一个进程触发事件。下面是一个 Event 事件示例：

import multiprocessing
import time

def worker(event, count):
    event.wait()
    print('Worker {} is working'.format(count))

if __name__ == '__main__':
    event = multiprocessing.Event()
    workers = []
    for i in range(10):
        p = multiprocessing.Process(target=worker, args=(event, i))
        workers.append(p)
        p.start()

    time.sleep(3)
    event.set()

在这个示例中，我们创建了 10 个进程，它们都等待事件的触发。当事件被触发时，所有等待事件的进程都会被唤醒，并开始执行。在这个示例中，我们使用 time.sleep() 方法来模拟一个进程在等待事件之前进行一些初始化的操作。然后，我们使用 event.set() 方法来触发事件的发生。