Python并发编程之进程（守护进程、锁、信号量）

港控/mmm° 2022-11-25 13:17 232阅读 0赞

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

友情链接：

1.  [Python多进程中的multiprocessing][Python_multiprocessing]
2.  [Python多进程中的fork][Python_fork]

### 文章目录 ###

*   *  一、守护进程（daemon）
     *   *  1.1 守护进程概念
         *  1.2 守护进程示例
         *  1.3 多个子进程的情况
     *  二、互斥锁（Lock）
     *   *  2.1 互斥锁概念
         *  2.2 互斥锁作用
         *  2.3 互斥锁示例
         *  2.4 区分同步和异步
     *  三、Semaphore（信号量）

## 一、守护进程（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("主进程执行结束")

![在这里插入图片描述][20200809155716236.png]  
**因为为守护主进程，主进程结束子进程立即结束。**

### 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("主进程代码执行结束...")

![在这里插入图片描述][20200809160136320.png]

## 二、互斥锁（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)

![在这里插入图片描述][20200809175231652.png]

注意：输出结果没有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()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70]

## 三、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()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 1]

[Python_multiprocessing]: https://luckylifes.blog.csdn.net/article/details/107885692
[Python_fork]: https://luckylifes.blog.csdn.net/article/details/107850251
[20200809155716236.png]: /images/20221124/3c5527846dae4a9f8f9e2cb7ae32bfb8.png
[20200809160136320.png]: /images/20221124/ca0d6ef2a27c4a72be692375694e4f43.png
[20200809175231652.png]: /images/20221124/3ebcfeffd4c1483a97d059849e07451d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70]: /images/20221124/078fd438b2f44772adc503af866f053c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 1]: /images/20221124/f19110320aba4bebb93c17ca849b1747.png