python_并发编程——锁

多进程模拟买票~

import time
import json
from multiprocessing import Process

class Show(Process):    #查
    def run(self):
        with open(‘ticket‘) as f:
            dic = json.load(f)
            print("余票:{}".format(dic[‘ticket‘]))

class Buy_ticket(Process):  #买
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        with open(‘ticket‘) as f:
            dic = json.load(f)
            time.sleep(0.1) #模拟网络延迟
        if dic[‘ticket‘] > 0:
            dic[‘ticket‘] -=1
            print(‘{}买到票了~~~‘.format(self.name))
            time.sleep(0.1) #模拟网络延迟
            with open(‘ticket‘,‘w‘) as f:
                json.dump(dic,f)
        else:
            print(‘{}没买到票!!!‘.format(self.name))
if __name__ == ‘__main__‘:
    for i in range(10):
        q1 = Show()
        q1.start()
    for i in range(10):
        i = str(i)
        q2 = Buy_ticket(i)
        q2.start()

json文件:结果:余票为1却有两个人买到票了~。

加上锁之后

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

class Show(Process):    #查
    def run(self):
        with open(‘ticket‘) as f:
            dic = json.load(f)
            print("余票:{}".format(dic[‘ticket‘]))

class Buy_ticket(Process):  #买
    def __init__(self,name,lock):   #接收锁对象
        super().__init__()
        self.name = name
        self.lock = lock
    def run(self):
        self.lock.acquire()     #拿钥匙进门
        with open(‘ticket‘) as f:
            dic = json.load(f)
            time.sleep(0.1) #模拟网络延迟
        if dic[‘ticket‘] > 0:
            dic[‘ticket‘] -=1
            print(‘{}买到票了~~~‘.format(self.name))
            time.sleep(0.1) #模拟网络延迟
            with open(‘ticket‘,‘w‘) as f:
                json.dump(dic,f)
        else:
            print(‘{}没买到票!!!‘.format(self.name))
        self.lock.release()     #还钥匙
if __name__ == ‘__main__‘:
    for i in range(10):
        q1 = Show()
        q1.start()
    lock = Lock()   #定义一个锁对象
    for i in range(10):
        i = str(i)
        q2 = Buy_ticket(i,lock) #将锁对象传入子进程
        q2.start()

json文件:结果:就只有三个人买到了~~

原文地址:https://www.cnblogs.com/wangdianchao/p/12044316.html

时间: 2024-11-03 23:52:39

python_并发编程——锁的相关文章

Java多线程并发编程/锁的理解

一.前言 最近项目遇到多线程并发的情景(并发抢单&恢复库存并行),代码在正常情况下运行没有什么问题,在高并发压测下会出现:库存超发/总库存与sku库存对不上等各种问题. 在运用了 限流/加锁等方案后,问题得到解决. 限流方案见本人另一篇博客:Guava-RateLimiter实现令牌桶限流 二.乐观锁 & 悲观锁 1.乐观锁   顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号(versio

python 并发编程 锁 / 信号量 / 事件 / 队列(进程间通信(IPC)) /生产者消费者模式

(1)锁:进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争,竞争带来的结果就是错乱,如何控制,就是加锁处理. 虽然使用加锁的形式实现了顺序的执行,但是程序又重新变成串行了,这样确实会浪费了时间,却保证了数据的安全. (Lock) import json from multiprocessing import Process,Lock ###### 锁 ###### import time import random def get

python_并发编程——多线程

1.多线程并发 from threading import Thread import time def func(n): time.sleep(1) print(n) for i in range(10): t = Thread(target=func,args=(i,)) #将函数注册进子线程,并传递参数 t.start() #启动子线程 结果:  2.另外一种启动多线程的方法 from threading import Thread import time class MyTread(Th

python_并发编程——多进程的第二种启动方式

1.多进程的第二种启动方式 import os from multiprocessing import Process # 创建一个自定义类,继承Process类 class MyProcess(Process): # 必须实现一个run方法,run方法中是子进程中执行的代码 def run(self): print('子进程:',os.getpid()) if __name__ == '__main__': print('主进程',os.getpid()) p1 = MyProcess() p

python_并发编程——管道和数据共享

1.管道 from multiprocessing import Pipe conn1,conn2 = Pipe() #返回两个值 conn1.send('wdc') #发送 print(conn2.recv()) #接收 conn2.send('yhf') print(conn1.recv()) 结果:~双向通信 2.在进程中传递数据 from multiprocessing import Pipe,Process class Pr1(Process): def __init__(self,c

python_并发编程——数据共享

1.数据共享 实现进程之间的数据共享 from multiprocessing import Manager,Process class MyPro(Process): def __init__(self,dic): super().__init__() self.dic = dic def run(self): self.dic['count'] -= 1 print(self.dic) if __name__ == '__main__': m = Manager() dic = m.dict

python_并发编程——进程池

1.进程池 from multiprocessing import Pool def func(n): for i in range(10): print(n+1) if __name__ == '__main__': pool = Pool(3) #启动有三个进程的进程池. #第一个参数进程要访问的代码,第二个参数必须是一个可迭代参数,规定了要执行的任务数 pool.map(func,range(100)) #100个任务 结果: 每个数打印了10次. 2.进程池和多进程的用时对比 def f

python_并发编程——线程池

1.线程池 import time from concurrent.futures import ThreadPoolExecutor def func(n): time.sleep(2) print(n) t_pool = ThreadPoolExecutor(max_workers=5) # 创建线程池对象,设置线程池大小,建议不超过cpu数*5 for i in range(20): t_pool.submit(func,i) # 启动进程池,(执行的函数,传递的参数) 结果:每过两秒钟随

Java并发编程:Concurrent锁机制解析

.title { text-align: center } .todo { font-family: monospace; color: red } .done { color: green } .tag { background-color: #eee; font-family: monospace; padding: 2px; font-size: 80%; font-weight: normal } .timestamp { color: #bebebe } .timestamp-kwd