进程同步
Lock
多个进程在访问共享资源时，为了保证资源被访问时的有序性，我们需要对多进程进行同步管理，可以使用Lock
from multiprocessing import Lock
lock = Lock()
lock.acquire()
# 其中包含的业务逻辑将被锁加持，其他进程在没有获取锁时，无法访问资源
lock.release()
# 释放锁
- 锁还可以通过上下文语句进行使用
with lock:
do something...
- 代码示例
from multiprocessing import Lock,Process,current_process
import time
def work_1(lock):
lock.acquire()
for var in range(10):
print(var)
time.sleep(0.5)
lock.release()
def work_2(lock):
with lock:
for var in range(10,20):
print(var)
def main():
lock = Lock()
p1 = Process(target=work_1,args=(lock,))
p2 = Process(target=work_2,args=(lock,))
p1.start()
p2.start()
p1.join()
p2.join()
if __name__ == '__main__':
main()
Semphore
lock是一把锁，Semaphore是N把锁，可以使多个进程同时持有，同时访问锁住的资源
semphore也叫做信号量
信号量一般用在某些资源可以被多个进程同时并发访问，构成多进程并发同步
同样的，一个信号量可以代表一种资源
from multiprocessing import Semphore
s_lock = Semaphore(num)
s_lock.acquire() # 加持锁，每次调用，信号量减一
s_lock.release() # 释放锁，每次调用，信号量加一
- 代码示例
from multiprocessing import Semaphore,Process,current_process
import time
def func(s_lock):
s_lock.acquire()
for var in range(10):
time.sleep(0.5)
print(var)
s_lock.release()
def main():
s = Semaphore(3)
process_ = []
for var in range(10):
process_.append(Process(target=func,args=(s,)))
for _ in process_:
_.start()
for _ in process_:
_.join()
if __name__ == '__main__':
main()
