Python进程同步之lock、semphore

前言

这几年一直在it行业里摸爬滚打，一路走来，不少总结了一些python行业里的高频面试，看到大部分初入行的新鲜血液，还在为各样的面试题答案或收录有各种困难问题

于是乎，我自己开发了一款面试宝典，希望能帮到大家，也希望有更多的Python新人真正加入从事到这个行业里，让python火不只是停留在广告上。

微信小程序搜索：Python面试宝典

或可关注原创个人博客：https://lienze.tech

也可关注微信公众号，不定时发送各类有趣猎奇的技术文章：Python编程学习

进程同步

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()