同步的方法基本与多线程相同。
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