Python 进程互斥锁 Lock - Python零基础入门教程

绝地灬酷狼 2022-10-11 13:44 299阅读 0赞

*  一.Python 线程互斥锁和进程互斥锁
    
     *  1.创建线程互斥锁
     *  2.创建进程互斥锁
 *  二.进程互斥锁 Lock 函数介绍
 *  三.进程互斥锁 Lock 使用
    
     *  案例一:使用进程，但不使用互斥锁
     *  案例二：进程互斥锁的使用
     *  案例三：对全局变量累计求和看看计算结果
 *  四.猜你喜欢

和前面讲到的 [**Python 线程互斥锁 Lock**][Python _ Lock] 类似，当有多个进程 Process 同时读写同一个文件时，为了避免数据读写产生异常，我们需要为正在操作的进程加上互斥锁，互斥锁的原理不管是对[线程 threading][threading] 还是对[进程 Process][Process] 而言都是一样。

## 一.Python 线程互斥锁和进程互斥锁 ##

### 1.创建线程互斥锁 ###

### 2.创建进程互斥锁 ###

注意导入模块的区别，不要混淆使用！

## 二.进程互斥锁 Lock 函数介绍 ##

*  **`acquire` — 锁定资源；**
 *  **`release` — 释放资源;**

## 三.进程互斥锁 Lock 使用 ##

### 案例一:使用进程，但不使用互斥锁 ###

# !usr/bin/env python
    # -*- coding:utf-8 _*-
    """
    @Author:猿说编程
    @Blog(个人博客地址): www.codersrc.com
    @File:Python 进程互斥锁 Lock.py
    @Time:2021/05/09 07:37
    @Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
    
    """
    
    from multiprocessing import Lock, Process
    import time
    import random
    import os
    
    
    def foo(i, mutex):
        print('%s: %s is running' % (i, os.getpid()))
        time.sleep(random.random())
        print('%s:%s is done' % (i, os.getpid()))
    
    
    if __name__ == '__main__':
        mutex = Lock()
        for i in range(10):
            process = Process(target=foo, args=(i, mutex))
            process.start()
    
    '''
    输出结果：
    
    0: 17008 is running
    1: 5288 is running
    2: 1228 is running
    3: 9724 is running
    4: 7520 is running
    5: 10236 is running
    3:9724 is done
    6: 16452 is running
    7: 13328 is running
    0:17008 is done
    8: 9356 is running
    9: 16432 is running
    8:9356 is done
    2:1228 is done
    5:10236 is done
    9:16432 is done
    7:13328 is done
    4:7520 is done
    6:16452 is done
    1:5288 is done
    '''

重输出的结果来看，多个进程同时在操作，如果是对同一个文件读写操作，很明显已经乱套了，这并不是我们想要的；如果多进程在读写同一文件时想要保证数据安全，必然需要加上[互斥锁 Lock][Lock]，例如下面这个 demo ；

### 案例二：进程互斥锁的使用 ###

# !usr/bin/env python
    # -*- coding:utf-8 _*-
    """
    @Author:猿说编程
    @Blog(个人博客地址): www.codersrc.com
    @File:Python 进程互斥锁 Lock.py
    @Time:2021/05/09 07:37
    @Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
    
    """
    
    from multiprocessing import Lock, Process
    import time
    import random
    import os
    
    
    def foo(i, mutex):
        mutex.acquire()
        print('%s: %s is running' % (i, os.getpid()))
        time.sleep(random.random())
        print('%s:%s is done' % (i, os.getpid()))
        mutex.release()
    
    
    if __name__ == '__main__':
        mutex = Lock()
        for i in range(10):
            process = Process(target=foo, args=(i, mutex))
            process.start()
    
    '''
    输出结果：
    
    0: 6908 is running
    0:6908 is done
    1: 7976 is running
    1:7976 is done
    3: 7824 is running
    3:7824 is done
    2: 17328 is running
    2:17328 is done
    4: 7844 is running
    4:7844 is done
    5: 15900 is running
    5:15900 is done
    6: 12648 is running
    6:12648 is done
    7: 16516 is running
    7:16516 is done
    8: 17348 is running
    8:17348 is done
    9: 13180 is running
    9:13180 is done
    '''

完美，即便是对同一个文件进行读写操作，进程 Process 使用互斥锁 Lock 之后也不会造成数据混乱的问题，同时也提高了效率，完美解决案例一的问题！

### 案例三：对全局变量累计求和看看计算结果 ###

# !usr/bin/env python
    # -*- coding:utf-8 _*-
    """
    @Author:猿说编程
    @Blog(个人博客地址): www.codersrc.com
    @File:Python 进程互斥锁 Lock.py
    @Time:2021/05/09 07:37
    @Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
    
    """
    
    # 导入进程模块
    from multiprocessing import Process,Lock
    
    num = 0
    
    def get_sum1():
    
        global num  # 声明全局变量
        for i in range(10000):
            num = num +1
        print("get_sum1:",num)
    
    def get_sum2():
    
        global num  # 声明全局变量
        for i in range(10000):
            num = num + 1
        print("get_sum2:", num)
    
    
    def main():
        global num  # 声明全局变量
        p1 = Process(target=get_sum1)
        p1.start()
    
        p2 = Process(target=get_sum2)
        p2.start()
    
        p1.join()
        p2.join()
        print("main:",num)
    
    
    if __name__ == "__main__":
    
        main()
        print("main exit")
    
    '''
    输出结果：
    
    get_sum1: 10000
    get_sum2: 10000
    main: 0
    main exit
    '''

可能有小伙伴会觉得很纳闷，main 函数中得 num 值怎么会是 0 ，明明主进程/两个子进程都用关键字[ \*\*global \*\*][_global]声明了全局变量，即便没有互斥锁，也应该是一个小于 20000 的随机数，在文章 [**Python 进程 Process 与线程 threading 区别**][Python _ Process _ threading] 中有详细讲解，**同一进程的所有线程共享该进程的所有资源，进程与进程之间资源相互独立，互不影响（类似[深拷贝][Link 1]）**；

上面的程序有三个进程，这就意味着 num 变量实际上有三份资源，其中两个进程对 num 分别做了 10000 次累计加 1 ，所以每个子进程的值都是 10000 ，主进程没有对 num 任何操作，所以主进程 num 值为 0 ；

## 四.**猜你喜欢** ##

1.  [Python 条件推导式][Python]
2.  [Python 列表推导式][Python 1]
3.  [Python 字典推导式][Python 2]
4.  [Python 不定长参数 \*argc/\*\*kargcs][Python _ _argc_kargcs]
5.  [Python 匿名函数 lambda][Python _ lambda]
6.  [Python return 逻辑判断表达式][Python return]
7.  [Python is 和 == 区别][Python is _ _]
8.  [Python 可变数据类型和不可变数据类型][Python 3]
9.  [Python 浅拷贝和深拷贝][Link 1]
10. [Python 异常处理][Python 4]
11. [Python 线程创建和传参][threading]
12. [Python 线程互斥锁 Lock][Python _ Lock]
13. [Python 线程时间 Event][Python _ Event]
14. [Python 线程条件变量 Condition][Python _ Condition]
15. [Python 线程定时器 Timer][Python _ Timer]
16. [Python 线程信号量 Semaphore][Python _ Semaphore]
17. [Python 线程障碍对象 Barrier][Python _ Barrier]
18. [Python 线程队列 Queue – FIFO][Python _ Queue _ FIFO]
19. [Python 线程队列 LifoQueue – LIFO][Python _ LifoQueue _ LIFO]
20. [Python 线程优先队列 PriorityQueue][Python _ PriorityQueue]
21. [Python 线程池 ThreadPoolExecutor(一)][Python _ ThreadPoolExecutor]
22. [Python 线程池 ThreadPoolExecutor(二)][Python _ ThreadPoolExecutor 1]
23. [Python 进程 Process 模块][Process]
24. [Python 进程 Process 与线程 threading 区别][Python _ Process _ threading]
25. [Python 进程间通信 Queue / Pipe][Python _ Queue _ Pipe]

未经允许不得转载：[猿说编程][Link 2] » [Python 进程互斥锁 Lock][Lock]

[Python _ Lock]: https://www.codersrc.com/archives/6048.html
[threading]: https://www.codersrc.com/archives/6015.html
[Process]: https://www.codersrc.com/archives/6765.html
[Lock]: https://www.codersrc.com/archives/6854.html
[_global]: https://www.codersrc.com/archives/5156.html
[Python _ Process _ threading]: https://www.codersrc.com/archives/6788.html
[Link 1]: https://www.codersrc.com/archives/5492.html
[Python]: https://www.codersrc.com/archives/5346.html
[Python 1]: https://www.codersrc.com/archives/5359.html
[Python 2]: https://www.codersrc.com/archives/5377.html
[Python _ _argc_kargcs]: https://www.codersrc.com/archives/5443.html
[Python _ lambda]: https://www.codersrc.com/archives/5756.html
[Python return]: https://www.codersrc.com/archives/5759.html
[Python is _ _]: https://www.codersrc.com/archives/5288.html
[Python 3]: https://www.codersrc.com/archives/5271.html
[Python 4]: https://www.codersrc.com/archives/5966.html
[Python _ Event]: https://www.codersrc.com/archives/6486.html
[Python _ Condition]: https://www.codersrc.com/archives/6508.html
[Python _ Timer]: https://www.codersrc.com/archives/6538.html
[Python _ Semaphore]: https://www.codersrc.com/archives/6563.html
[Python _ Barrier]: https://www.codersrc.com/archives/6581.html
[Python _ Queue _ FIFO]: https://www.codersrc.com/archives/6609.html
[Python _ LifoQueue _ LIFO]: https://www.codersrc.com/archives/6651.html
[Python _ PriorityQueue]: https://www.codersrc.com/archives/6674.html
[Python _ ThreadPoolExecutor]: https://www.codersrc.com/archives/6707.html
[Python _ ThreadPoolExecutor 1]: https://www.codersrc.com/archives/6732.html
[Python _ Queue _ Pipe]: https://www.codersrc.com/archives/6826.html
[Link 2]: https://www.codersrc.com