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

目录

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

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

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

1.创建线程互斥锁

# !usr/bin/env python
# -*- coding:utf-8 _*-
\"\"\"
@Author:猿说编程
@Blog(个人博客地址): www.codersrc.com
@File:Python 进程互斥锁 Lock.py
@Time:2021/05/09 07:37
@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！

\"\"\"

# 导入线程threading模块
import threading

# 创建线程互斥锁
mutex = threading.Lock()

2.创建进程互斥锁

# !usr/bin/env python
# -*- coding:utf-8 _*-
\"\"\"
@Author:猿说编程
@Blog(个人博客地址): www.codersrc.com
@File:Python 进程互斥锁 Lock.py
@Time:2021/05/09 07:37
@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！

\"\"\"

from multip# 导入进程模块
from multiprocessing import Process,Lock

# 创建进程互斥锁
mutex = Lock()

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

二.进程互斥锁 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，例如下面这个 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 **声明了全局变量，即便没有互斥锁，也应该是一个小于 20000 的随机数，在文章 Python 进程 Process 与线程 threading 区别 中有详细讲解，同一进程的所有线程共享该进程的所有资源，进程与进程之间资源相互独立，互不影响（类似深拷贝）；

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

四.猜你喜欢

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

本文由博客 - 猿说编程 猿说编程 发布！

来源：https://www.cnblogs.com/shuopython/p/14957446.html
图文来源于网络，如有侵权请联系删除。