python并发编程之semaphore(信号量)_浅谈Python并发编程之进程（守护进程、锁、信号量）...

前言：本博文是对Python并发编程之进程的知识延伸，主要讲解：守护进程、锁、信号量。

友情链接：

一、守护进程(daemon)

1.1 守护进程概念

首先我们都知道：正常情况下，主进程默认等待子进程调用结束之后再结束，守护进程在主进程所有代码执行完毕之后，自动终止。当然我们也可以使用kill -9 进程号，杀死进程。

那么接下来，我们看一下守护进程的语法：

进程对象.daemon = True

通过上面的代码，我们就可以设置该进程为守护进程。

注意： 必须要写在start()方法之前赋值。

此时，将设置为主进程守护，主进程如果代码执行结束了，该守护进程自动结束。

1.2 守护进程示例

from multiprocessing import Process

import time

def func():

print("子进程start")

time.sleep(1)

print("子进程end")

if __name__ == "__main__":

p = Process(target=func)

p.daemon = True

p.start()

time.sleep(1)

print("主进程执行结束")

因为为守护主进程，主进程结束子进程立即结束。

1.3 多个子进程的情况

当多个子进程并发执行时，默认主进程等待子进程，如果标记该子进程是守护进程，当主进程执行完毕所有代码之后，守护进程立刻终止。

主进程的代码执行到最后一行，就意味着函数代码执行完毕，此时就应该杀掉守护进程。其他非守护进程继续正常执行，主进程仍然等待直到结束，最后主进程在真正的释放结束。

from multiprocessing import Process

import time

def func1():

count = 1

while True:

print("*" * count)

time.sleep(0.5)

count +=1

def func2():

print("func2 start")

time.sleep(3)

print("func2 end")

if __name__ == "__main__":

p1 = Process(target=func1)

p1.daemon = True

p1.start()

p2 = Process(target=func2)

p2.start()

print("主进程代码执行结束...")

二、互斥锁(Lock)

上锁：lock.acquire()

解锁：lock.release()

2.1 互斥锁概念

同一时间允许一个进程上一把锁，就是Lock。那么我们加锁的意义在哪呢？加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改。虽然我们的程序运行速度是慢了，但牺牲速度却保证了数据安全。

同一时间允许多个进程上多把锁 就是[信号量Semaphore]。

信号量是锁的变形：实际实现是 计数器 + 锁，同时允许多个进程上锁。

2.2 互斥锁作用

互斥锁Lock：互斥锁就是进程的相互排斥。

谁先抢到自由，谁就上锁该资源内容，这样做可以保证数据的同步性。

注意：多个锁一起上，不开锁，会造成死锁，上锁和解锁是一对。

2.3 互斥锁示例

from multiprocessing import Process, Lock

# 创建一把锁

lock = Lock()

# 上锁

lock.acquire()

print(1)

# 解锁

lock.release()

# 死锁 : 只上锁,不解锁,会阻塞,产生死锁

lock.acquire()

print(2)

lock.release()

print(3)

lock.acquire()

print(4)

#lock.release()：在这里我们不解锁

lock.acquire()

print(5)

注意：输出结果没有5，因为上一个锁，没有解锁，造成了死锁。

2.4 区分同步和异步

在产生进程对象的时候，进程之间是异步，上锁之后，进程之间变成同步。

from multiprocessing import Process,Lock

def func(num, lock):

lock.acquire()

print("走到上锁这个地方,变成一个同步程序,先来的进行先执行,后来的进程后执行,按次序依次执行")

print(num)

lock.release()

if __name__ == "__main__":

# lock互斥锁, 进程之间数据不共享

# 但是lock对象底层是通过socket来互相发送数据,不管多少进程,都是同一个lock锁

lock = Lock()

for i in range(3):

p = Process(target=func, args=(i, lock))

# 1. 10个子进程异步执行,是并发操作

p.start()

三、Semaphore(信号量)

信号量Semaphore是一个计数器，控制对公共资源或者临界区域的访问量，信号量可以指定同时访问资源或者进入临界区域的进程数。每次有一个进程获得信号量时，计数器－1，若计数器为0时，其他进程就停止访问信号量，一直阻塞直到其他进程释放信号量。

我们之前说到的Lock，属于互斥锁，也就是一把钥匙配备一把锁，同时只允许锁住某一个数据。而信号量则是多把钥匙配备多把锁，也就是说同时允许锁住多个数据。

from multiprocessing import Process,Semaphore

import random,time

def ktv(person,sem):

# 上锁

sem.acquire()

print("%s进入ktv唱歌" % (person))

time.sleep(random.randrange(3, 8))

print("%s走出ktv离开" % (person))

# 解锁

sem.release()

if __name__ == "__main__":

# 同一时间最多允许2个进程执行ktv任务,剩下的进程等待

sem = Semaphore(2)

for i in range(1, 6):

p = Process(target=ktv,args=("person%s" %i, sem))

p.start()