python-day33--互斥锁

锁的意思就是:一个一个的执行

 1 from multiprocessing import Process,Lock
 2 import os
 3 import time
 4 def work(mutex):
 5     mutex.acquire()
 6     print(‘task[%s] 上厕所‘ %os.getpid())
 7     time.sleep(3)
 8     print(‘task[%s] 上完厕所‘ %os.getpid())
 9     mutex.release()
10
11 if __name__ == ‘__main__‘:
12     mutex=Lock()
13     p1=Process(target=work,args=(mutex,))
14     p2=Process(target=work,args=(mutex,))
15     p3=Process(target=work,args=(mutex,))
16     p1.start()
17     p2.start()
18     p3.start()
19
20     print(‘主‘)

互斥锁

 1 from multiprocessing import Process,Lock
 2 import json
 3 import time
 4 import random
 5 import os
 6 def search():
 7     dic=json.load(open(‘a‘,))
 8     print(‘剩余票数%s‘ %dic[‘count‘])
 9
10 def get_ticket():
11     dic=json.load(open(‘a‘,))
12     if dic[‘count‘] > 0:
13         dic[‘count‘]-=1
14         json.dump(dic,open(‘a‘,‘w‘))
15         print(‘%s 购票成功‘ %os.getpid())
16 def task(mutex):
17     search()
18     time.sleep(random.randint(1, 3)) #模拟购票一系列繁琐的过程所花费的时间
19     mutex.acquire()
20     get_ticket()
21     mutex.release()
22 if __name__ == ‘__main__‘:
23     mutex=Lock()
24     for i in range(50):
25         p=Process(target=task,args=(mutex,))
26         p.start()

模拟抢票

时间: 2024-12-13 09:08:01

python-day33--互斥锁的相关文章

python线程互斥锁Lock(29)

在前一篇文章 python线程创建和传参 中我们介绍了关于python线程的一些简单函数使用和线程的参数传递,使用多线程可以同时执行多个任务,提高开发效率,但是在实际开发中往往我们会碰到线程同步问题,假如有这样一个场景:对全局变量累加1000000次,为了提高效率,我们可以使用多线程完成,示例代码如下: # !usr/bin/env python # -*- coding:utf-8 _*- """ @Author:何以解忧 @Blog(个人博客地址): shuopython

Python的互斥锁与信号量

并发与锁 a. 多个线程共享数据的时候,如果数据不进行保护,那么可能出现数据不一致现象,使用锁,信号量.条件锁 b. c.互斥锁1. 互斥锁,是使用一把锁把代码保护起来,以牺牲性能换取代码的安全性,那么Rlock后 必须要relase 解锁 不然将会失去多线程程序的优势2. 互斥锁的基本使用规则: 1 import threading 2 # 声明互斥锁 3 lock=threading.Rlock(); 4 def handle(sid):# 功能实现代码 5 lock.acquire() #

Python进阶(3)_进程与线程中的lock(互斥锁、递归锁、信号量)

1.同步锁 (Lock) 当各个线程需要访问一个公共资源时,会出现数据紊乱 例如: 1 import threading,time 2 def sub(): 3 global num #对全局变量进行操作 4 5 temp=num 6 time.sleep(0.001) #模拟线程执行中出现I/o延迟等 7 num=temp-1 #所有线程对全局变量进行减一 8 9 time.sleep(1) 10 11 num=100 12 l=[] 13 14 for i in range(100): 15

11.python并发入门(part3 多线程与互斥锁)

一.锁的概念. 锁,通常被用来实现共享数据的访问,为每一个共享的数据,创建一个Lock对象(一把锁),当需要访问这个共享的资源时,可以调用acquire方法来获取一个锁的对象,当共享资源访问结束后,在调用release方法去解锁. 二.python中的互斥锁. 在介绍互斥锁之前,先来一起看一个例子.(每个线程对num实现一次-1的操作) import threading import  time num = 200  #每个线程都共享这个变量. tread_list = [] def count

python并发编程之多进程(二):互斥锁(同步锁)&进程其他属性&进程间通信(queue)&生产者消费者模型

一,互斥锁,同步锁 进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的, 竞争带来的结果就是错乱,如何控制,就是加锁处理 part1:多个进程共享同一打印终端 #并发运行,效率高,但竞争同一打印终端,带来了打印错乱 from multiprocessing import Process import os,time def work(): print('%s is running' %os.getpid()) time.sleep(2) print('

Python之路(第三十八篇) 并发编程:进程同步锁/互斥锁、信号量、事件、队列、生产者消费者模型

一.进程锁(同步锁/互斥锁) 进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的, 而共享带来的是竞争,竞争带来的结果就是错乱,如何控制,就是加锁处理. 例子 #并发运行,效率高,但竞争同一打印终端,带来了打印错乱 from multiprocessing import Process import os,time def work(): print('%s is running' %os.getpid()) time.sleep(2) print('

Python Threading 线程/互斥锁/死锁/GIL锁

导入线程包 import threading 准备函数线程,传参数 t1 = threading.Thread(target=func,args=(args,)) 类继承线程,创建线程对象 class MyThread(threading.Thread) def run(self): pass if __name__ == "__main__": t = MyThread() t.start() 线程共享全面变量,但在共享全局变量时会出现数据错误问题使用 threading 模块中的

python并发编程-进程理论-进程方法-守护进程-互斥锁-01

操作系统发展史(主要的几个阶段) 初始系统 1946年第一台计算机诞生,采用手工操作的方式(用穿孔卡片操作) 同一个房间同一时刻只能运行一个程序,效率极低(操作一两个小时,CPU一两秒可能就运算完了) 联机批处理系统 脱机批处理系统 多道程序系统 1.空间上的复用 ? 多个程序公用一套计算机硬件 2.时间上的复用 ? 切换+保存状态 ? 保存状态:保存当前的运行状态,下次接着该状态继续执行 ? 切换的两种情况 ? (1) 当一个程序遇到 I/O 操作(不需要使用CPU),操作系统会剥夺该程序的C

【Python下进程同步之互斥锁、信号量、事件机制】 -- 2019-08-16 17:58:28

原文: http://blog.gqylpy.com/gqy/229 " 一.锁机制:??multiprocess.Lock 上篇博客中,我们千方百计实现了程序的异步,让多个任务同时在几个进程中并发处理,但它们之间的运行没有顺序.尽管并发编程让我们能更加充分的利用io资源,但是也给我我们带来了新问题,多个进程使用同一份数据资源的时候,就会引发数据安全或顺序混乱问题. 例: # 多进程抢占输出资源 from multiprocessing import Process from os import

【Python下进程同步之互斥锁、信号量、事件机制】 𪕽

原文: http://blog.gqylpy.com/gqy/229 " 一.锁机制:??multiprocess.Lock 上篇博客中,我们千方百计实现了程序的异步,让多个任务同时在几个进程中并发处理,但它们之间的运行没有顺序.尽管并发编程让我们能更加充分的利用io资源,但是也给我我们带来了新问题,多个进程使用同一份数据资源的时候,就会引发数据安全或顺序混乱问题. 例: # 多进程抢占输出资源 from multiprocessing import Process from os import