Python之进程锁

最新推荐文章于 2024-01-24 23:35:16 发布
最新推荐文章于 2024-01-24 23:35:16 发布
阅读量1.3k 收藏 3
点赞数 1
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40199698/article/details/89281687
版权

背景：多个进程操作同一个资源，会引发数据安全问题

# 模拟买票过程
from multiprocessing import Process
import time
import json

# 首先创建一个余票文件
# dic = {'ticket':1}
# f = open('ticketDB','w')
# json.dump(dic,f)
# f.close()

# 定义一个买票类
class BuyTicket:
    def __init__(self,ticketDB):
        self.__ticketDB=ticketDB
    # 定义一个查看余票的方法
    def showTicket(self,name):
        # 查看票据有网络延迟
        time.sleep(0.2)
        tickets = self.getTicket()
        print("%s查看余票数："%(name),tickets['ticket'])
    # 定义一个获取余票的方法
    def getTicket(self):
        ticketNum = json.load(open(self.__ticketDB))
        return ticketNum
    # 定义一个买票的方法
    def buyTicket(self,name):
        # 买票要先获取余票数，也存在网络延迟
        time.sleep(0.2)
        tickets = self.getTicket()
        if tickets['ticket'] > 0:
            tickets['ticket'] = tickets['ticket'] - 1
            # 将买完后的余票数写回到数据库中,存在网络延迟
            time.sleep(0.2)
            f = open(self.__ticketDB,'w')
            json.dump(tickets,f)
            f.close()
            print("%s买到票了"%(name))
        else:
            print("%s没有买到票"%(name))
# 开始模拟10个人买票
bt = BuyTicket('ticketDB')
if __name__ == '__main__':
    # 10个人来查看余票
    for i in range(1,11):
        p = Process(target=bt.showTicket,args=(i,))
        p.start()
    # 10个人抢票
    for i in range(1,11):
        p = Process(target=bt.buyTicket,args=(i,))
        p.start()
'''
输出结果：
1查看余票数： 1
2查看余票数： 1
3查看余票数： 1
4查看余票数： 1
5查看余票数： 1
6查看余票数： 1
7查看余票数： 1
8查看余票数： 1
9查看余票数： 1
10查看余票数： 1
1买到票了
7没有买到票
8没有买到票
2买到票了
3买到票了
9没有买到票
4买到票了
10没有买到票
5买到票了
6买到票了
'''

由以上可以看出：余票只有一张，但确有多个人买到了票，即出现了数据安全问题

引入进程锁，可以解决这个问题

from multiprocessing import Process
from multiprocessing import Lock
import time
import json

# 首先创建一个余票文件
dic = {'ticket':1}
f = open('ticketDB','w')
json.dump(dic,f)
f.close()

# 定义一个买票类
class BuyTicket:
    def __init__(self,ticketDB):
        # 定义一个锁
        self.__lock = Lock()
        self.__ticketDB=ticketDB
    # 定义一个查看余票的方法
    def showTicket(self,name):
        # 查看票据有网络延迟
        time.sleep(0.2)
        tickets = self.getTicket()
        print("%s查看余票数："%(name),tickets['ticket'])
    # 定义一个获取余票的方法
    def getTicket(self):
        ticketNum = json.load(open(self.__ticketDB))
        return ticketNum
    # 定义一个买票的方法
    def buyTicket(self,name):
        # 买票要先获取余票数，也存在网络延迟
        time.sleep(0.2)
        # 在网络延迟后，获取到票，到买完回写到票据中心的过程加锁，其它进程在这中间不可访问票据中心的数据
        self.__lock.acquire()
        tickets = self.getTicket()
        if tickets['ticket'] > 0:
            tickets['ticket'] = tickets['ticket'] - 1
            time.sleep(0.2)
            f = open(self.__ticketDB,'w')
            json.dump(tickets,f)
            f.close()
            print("%s买到票了"%(name))
        else:
            print("%s没有买到票"%(name))
        self.__lock.release()
# 开始模拟10个人买票
bt = BuyTicket('ticketDB')
if __name__ == '__main__':
    # 10个人来查看余票
    for i in range(1,11):
        p = Process(target=bt.showTicket,args=(i,))
        p.start()
    # 10个人抢票
    for i in range(1,11):
        p = Process(target=bt.buyTicket,args=(i,))
        p.start()
'''
2查看余票数： 1
1查看余票数： 1
3查看余票数： 1
4查看余票数： 1
5查看余票数： 1
6查看余票数： 1
7查看余票数： 1
8查看余票数： 1
9查看余票数： 1
10查看余票数： 1
1买到票了
2没有买到票
3没有买到票
4没有买到票
5没有买到票
6没有买到票
7没有买到票
8没有买到票
9没有买到票
10没有买到票
'''

加锁要加在合适的地方，否则回造成死锁问题，锁加错导致死锁的过程

from multiprocessing import Process
from multiprocessing import Lock
import time
import json

# 首先创建一个余票文件
dic = {'ticket':1}
f = open('ticketDB','w')
json.dump(dic,f)
f.close()

# 定义一个买票类
class BuyTicket:
    def __init__(self,ticketDB):
        # 定义一个锁
        self.__lock = Lock()
        self.__ticketDB=ticketDB
    # 定义一个查看余票的方法
    def showTicket(self,name):
        # 查看票据有网络延迟
        time.sleep(0.2)
        tickets = self.getTicket()
        print("%s查看余票数："%(name),tickets['ticket'])
    # 定义一个获取余票的方法
    def getTicket(self):
        ticketNum = json.load(open(self.__ticketDB))
        return ticketNum
    # 定义一个买票的方法
    def buyTicket(self,name):
        # 买票要先获取余票数，也存在网络延迟
        time.sleep(0.2)
        # 在网络延迟后，获取到票，到买完回写到票据中心的过程加锁，其它进程在这中间不可访问票据中心的数据
        self.__lock.acquire()
        tickets = self.getTicket()
        if tickets['ticket'] > 0:
            tickets['ticket'] = tickets['ticket'] - 1
            time.sleep(0.2)
            f = open(self.__ticketDB,'w')
            json.dump(tickets,f)
            f.close()
            self.__lock.release() # 最初锁加在了此处
            print("%s买到票了"%(name))
        else:
            print("%s没有买到票"%(name))
# 开始模拟10个人买票
bt = BuyTicket('ticketDB')
if __name__ == '__main__':
    # 10个人来查看余票
    for i in range(1,11):
        p = Process(target=bt.showTicket,args=(i,))
        p.start()
    # 10个人抢票
    for i in range(1,11):
        p = Process(target=bt.buyTicket,args=(i,))
        p.start()
'''
2查看余票数： 1
1查看余票数： 1
3查看余票数： 1
4查看余票数： 1
5查看余票数： 1
6查看余票数： 1
7查看余票数： 1
8查看余票数： 1
9查看余票数： 1
10查看余票数： 1
1买到票了
2没有买到票
程序到此卡住了
'''

当第二个人进来先申请了一个锁，但是发现票据余量为0，直接打印没有买到票则推出了，锁没有释放，因此造成了后续进程无法进程

CODE_Lph
关注
专栏目录
〖Python语法进阶篇④〗 - 进程池与进程锁
易编橙 · 终身成长社群，相遇已是上上签！
04-09 4万+
NICE！大家好，在上一章节，我们学习了 multiprocessing 模块 的关于进程的创建与进场常用的方法的相关知识。 通过在一个主进程下创建多个子进程可以帮助我们加速程序的运行，并且提高工作效率。不过上一章节文末我们也说过进程的问题，由于每一个进程都会消耗 `CPU 与 内存` 资源，这样就不能无限的创建进程的问题，因为会造成内存不足或者死机的情况。
python多进程之互斥锁
m0_50481455的博客
02-18 584
python多进程之互斥锁 现在有三个人同时用一个打印机打印内容 三个进程同时模拟这三个人，输出平台模拟打印机 我们先写一个普通的多进程来看看 from multiprocessing import Process import time import os import random def task1(): print(f"{os.getpid()}开始打印了") time.sleep(random.randint(1,3)) print(f"{os.getpid()}打印结束
对Python的多进程锁的使用方法详解
12-31
很多时候，我们需要在多个进程中同时写一个文件，如果不加锁机制，就会导致写文件错乱 这个时候，我们可以使用multiprocessing.Lock() 我一开始是这样使用的： import multiprocessing lock = multiprocessing.Lock() class MatchProcess(multiprocessing.Process): def __init__(self, threadId, mfile, lock): multiprocessing.Process.__init__(self) self.threadId = thread
python中的进程锁
qq_40723809的博客
01-21 300
import multiprocessing def work(f, item, lock): # lock.acquire() try: with open(f, 'a+') as f: f.write("a %s task\n" % (item)) except Exception as e: print("产生异...
Python笔记-进程Process、线程Thread、上锁
Marlboro
04-17 1330
进程Process、线程Thread、上锁
python之进程锁
likunkun__的博客
09-26 1389
进程锁：multiprocessing下的Lock方法 这个的主要作用是让进程不乱掉，下面代码就是可以避免 i 乱打印 from multiprocessing import Process, Lock def f(l, i): l.acquire() #锁住进程 try: print('hello world', i) finally: ...
python进程中的锁
weixin_56319791的博客
01-01 3010
python中进程的锁和线程的锁用法一样 Lock锁（只能锁一个，放一个） import multiprocessing import time lock = multiprocessing.Lock() def task(args): p = multiprocessing.current_process() lock.acquire() time.sleep(2) print(p.name) print(args) lock.release() d
Python简单进程锁代码实例
12-24
除此之外，我们在进程间通信时会用到信号，向某一个进程发送信号，该进程中设置信号处理函数，然后当该进程收到信号时，执行某些操作。 其实在线程中，也可以接受信号，利用这种机制，我们也可以用来实现线程同步。...
python 进程锁
anzhang5248的博客
06-18 176
作用：异步修改数据时，会造成数据安全问题，子进程分别进入文件/数据库，修改数据 """ 过程： 1.导入Lock模块 2.创建Lock对象 3.Lock对象做为要锁的进程的参数 4.lock.acquire() 5.lock.release() """ from multiprocessing import Process from multiprocessing...
python3 进程锁
热门推荐
十里平湖的博客
03-22 1万+
多进程抢占资源 当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。 import os import time import random from multiprocessing import Process,Lock def work(n): print('%s: %s is runing' % (n,os.getpid())) time.s...
python进程锁
qq_34577961的博客
03-06 814
# 进程锁的代价是，失去异步效果 # db.txt文件内容：{'count': 1} from multiprocessing import Process from multiprocessing import Lock import time import json def search(): time.sleep(1) f = open('db.txt','r',encoding='utf-8') r = f.read() tick.
Python之进程线程
weixin_30752377的博客
01-17 141
进程是最小的资源单位，线程是最小的执行单位 一、进程 进程：就是一个程序在一个数据集上的一次动...
41.python之进程锁
qq_41917061的博客
08-19 600
进程锁 多个进程之间虽然是独立的，但仅限于内存和运算，如果涉及到其它一些资源，就可能存在竞争问题，当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题，添加进程锁则可以解决此类问题。 进程锁，在同一时间执行一个进程 要注意，锁不能滥用，若是因为某些原因没有解锁，就会造成死锁的现象，这样后面的进程也就无法执行。 进程锁的创建：模块multiprocessing的Manager类 from multiprocessing import Manager manager = Manager() l
python基础——锁
最新发布
qq_63781342的博客
01-24 696
python基础——锁
python3 多进程锁
whatday的专栏
01-22 315
引入库 from multiprocessing import Lock 初始化 lock = Lock() 上锁 lock.acquire() 解锁 lock.release() 实例： from multiprocessing import Process import json import time from multiprocessing import Lock...
Python（进程锁）
qq_43281189的博客
01-22 986
1. 为什么要使用进程锁 1.1 当使用多进程对同一共享资源进行使用时，可能会出现各种问题，例如数据写入文件时顺序错误、当进程需要依 次修改同一个数据时，第一个进程还未完成修改，第二个进程就读取未经修改的数据进行修改。 2. 如何实现进程锁 2.1 import multiprocessing def work(f, item, lock): # 2). 开始此任务前，为防止数据写...
python 线程(创建2种方式,锁,死锁,递归锁,GIL锁,守护进程)
python学习者的博客
12-12 201
线程创建的2种方式(重点) 进程:资源分配单位 线程:cpu执行单位(实体) 线程的创建和销毁的开销特别小 线程之间资源共享,是同一个进程中的资源共享,会涉及到安全问题,所以需要加锁解决 锁:牺牲了效率,保证了数据安全(重点) 死锁现象:出现在嵌套的时候,双方互相抢对方已经拿到的锁,导致双方互相等待(重点) 递归锁: 解决了死锁现象(重点) rlock 首先本身就是个互斥锁,维护了一个计数器,每次acquire+1,release就-1,当计数器为0的时候,大家才会抢这个锁 守护线程:
Python3多进程编程中进程池锁共享
Python热爱者的博客
06-20 446
Python3多进程编程中进程池锁共享
c++和python的进程锁
07-09
C++和Python都支持进程锁来实现多线程或多进程间的同步。在C++中，可以使用`std::mutex`和`std::lock_guard`来创建进程锁。示例代码如下： ```cpp #include #include #include std::mutex mtx; void print...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值