铁乐学python_Day42_锁和队列

铁乐学python_Day42_锁和队列

例：多个线程抢占资源的情况
from threading import Thread
import timedef work():global ntemp = ntime.sleep(0.1)n = temp - 1if __name__ == '__main__':n = 100l = []for i in range(100):p = Thread(target=work)l.append(p)p.start()for p in l:p.join()print(n) # 很有可能n=99这个时候为了保障数据的安全，我们可以对公共数据使用锁锁起来。
import threading
R=threading.Lock()
R.acquire()
'''
对公共数据的操作
'''
R.release()例：加锁同步数据
from threading import Thread,Lock
import timedef work():global nlock.acquire()temp=ntime.sleep(0.1)n=temp-1lock.release()if __name__ == '__main__':lock=Lock()n=100l=[]for i in range(100):p=Thread(target=work)l.append(p)p.start()for p in l:p.join()print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全。例：互斥锁与join的区别
#不加锁:并发执行,速度快,数据不安全
from threading import current_thread,Thread,Lock
import time
def task():global nprint('%s is running' %current_thread().getName())temp=ntime.sleep(0.5)n=temp-1if __name__ == '__main__':n=100lock=Lock()threads=[]start_time=time.time()for i in range(100):t=Thread(target=task)threads.append(t)t.start()for t in threads:t.join()stop_time=time.time()print('主:%s n:%s' %(stop_time-start_time,n))'''
Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:0.5216062068939209 n:99
'''#部分数据加上同步锁:未加锁部分并发执行，加锁部分串行执行,速度慢,数据安全。
from threading import current_thread,Thread,Lock
import time
def task():#未加锁的代码并发运行time.sleep(3)print('%s start to run' %current_thread().getName())global n#加锁的代码串行运行lock.acquire()temp=ntime.sleep(0.5)n=temp-1lock.release()if __name__ == '__main__':n=100lock=Lock()threads=[]start_time=time.time()for i in range(100):t=Thread(target=task)threads.append(t)t.start()for t in threads:t.join()stop_time=time.time()print('主:%s n:%s' %(stop_time-start_time,n))'''
Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:53.294203758239746 n:0
'''#加锁会让运行变成串行,而在start之后立即使用join,不用加锁了也是串行的效果。那么为什么使用加锁呢？
#在start之后立刻使用jion,也会将100个任务的执行变成串行,最终n的结果是0,也是安全的,
#但问题是start后立即join:任务内的所有代码都是串行执行的,
#而加锁,只是加锁的部分即修改共享数据的部分是串行的,
#单从保证数据安全方面,二者都可以实现,但很明显是加锁的效率更高.from threading import current_thread,Thread,Lock
import time
def task():time.sleep(3)print('%s start to run' %current_thread().getName())global ntemp=ntime.sleep(0.5)n=temp-1if __name__ == '__main__':n=100lock=Lock()start_time=time.time()for i in range(100):t=Thread(target=task)t.start()t.join()stop_time=time.time()print('主:%s n:%s' %(stop_time-start_time,n))'''
Thread-1 start to run
Thread-2 start to run
......
Thread-100 start to run
主:350.6937336921692 n:0 #耗时是多么的恐怖
'''

死锁与递归锁死锁与递归锁

死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象。
若无外力作用，它们都将无法推进下去。
此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

如下就是死锁:
from threading import Lock as Lock
import time
mutexA=Lock()
mutexA.acquire()
mutexA.acquire()
print("铁乐猫")
mutexA.release()
mutexA.release()

解决方法，递归锁.

在Python中为了支持在同一线程中多次请求同一资源，python提供了递归锁RLock。
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。
直到一个线程所有的acquire都被release，其他的线程才能获得资源。
上面的例子如果使用RLock代替Lock，则不会发生死锁：

from threading import RLock as Lock
import time
mutexA=Lock()
mutexA.acquire()
mutexA.acquire()
print("铁乐猫")
mutexA.release()
mutexA.release()死锁典型例子：科学家吃面
import time
from threading import Thread,Lock
noodle_lock = Lock()
fork_lock = Lock()
def eat1(name):noodle_lock.acquire()print('%s 抢到了面条'%name)fork_lock.acquire()print('%s 抢到了叉子'%name)print('%s 吃面'%name)fork_lock.release()noodle_lock.release()def eat2(name):fork_lock.acquire()print('%s 抢到了叉子' % name)time.sleep(1)noodle_lock.acquire()print('%s 抢到了面条' % name)print('%s 吃面' % name)noodle_lock.release()fork_lock.release()for name in ['tiele','mao','铁乐猫']:t1 = Thread(target=eat1,args=(name,))t2 = Thread(target=eat2,args=(name,))t1.start()t2.start()递归锁解决科学家吃面中的死锁问题
import time
from threading import Thread,RLock
fork_lock = noodle_lock = RLock()
def eat1(name):noodle_lock.acquire()print('%s 抢到了面条'%name)fork_lock.acquire()print('%s 抢到了叉子'%name)print('%s 吃面'%name)fork_lock.release()noodle_lock.release()def eat2(name):fork_lock.acquire()print('%s 抢到了叉子' % name)time.sleep(1)noodle_lock.acquire()print('%s 抢到了面条' % name)print('%s 吃面' % name)noodle_lock.release()fork_lock.release()for name in ['tiele','mao','铁乐猫]:t1 = Thread(target=eat1,args=(name,))t2 = Thread(target=eat2,args=(name,))t1.start()t2.start()定时器(Timer)
定时器，指定n秒后执行某个操作。
例：
from threading import Timerdef hello():print("hello, world")t = Timer(1, hello)
t.start()  # after 1 seconds, "hello, world" will be printed

线程队列（queue队列）

queue队列 ：使用import queue，用法与进程中使用Queue一样。

队列长度可为无限或者有限。可通过Queue的构造函数的可选参数maxsize来设定队列长度。
如果maxsize小于1就表示队列长度无限。

调用队列对象的put()方法在队尾插入一个项目。
put()有两个参数，第一个item为必需的，为插入项目的值；
第二个block为可选参数，默认为1。
如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。
如果block为0，put方法将引发Full异常。

调用队列对象的get()方法从队头删除并返回一个项目。
可选参数为block，默认为True。
如果队列为空且block为True，get()就使调用线程暂停，直至有项目可用。
如果队列为空且block为False，队列将引发Empty异常。

python queue 模块有三种队列：

1）class queue.Queue(maxsize=0) #First In First Out
［FIFO 类似于栈 先进先出］
import queueq=queue.Queue()
q.put('first')
q.put('second')
q.put('third')print(q.get())
print(q.get())
print(q.get())
'''
结果(先进先出):
first
second
third
'''2）class queue.LifoQueue(maxsize=0) #Last In Fisrt Out
［LIFO 类似于堆 后进先出］import queueq=queue.LifoQueue()
q.put('first')
q.put('second')
q.put('third')print(q.get())
print(q.get())
print(q.get())
'''
结果(后进先出):
third
second
first
'''class queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列
［优先级队列 数字越小（优先级越高）越先取出］import queueq=queue.PriorityQueue()
#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
q.put((20,'a'))
q.put((10,'b'))
q.put((30,'c'))print(q.get())
print(q.get())
print(q.get())
'''
结果(数字越小优先级越高,优先级高的优先出队):
(10, 'b')
(20, 'a')
(30, 'c')
'''队列中的其它方法：
Queue.full    # 与maxsize大小对应
Queue.qsize() # 返回队列的大小
Queue.empty() # 队列若为空则返回True  
Queue.full()  # 队列若为满则返回True 
Queue.join()  # block（阻塞）直到queue被消费完毕，再执行后面的操作Queue.get([block[, timeout]]) # 获取队列，timeout等待时间
Queue.get_nowait()         # 相当Queue.get(False)
Queue.put(item)            # 非阻塞 写入队列，timeout等待时间
Queue.put_nowait(item)        # 相当Queue.put(item, False)
Queue.task_done()  # 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号例：使用多线程完成队列中的任务import queue
import threading
import time
import randomq = queue.Queue(0)  # 当有多个线程共享一个东西的时候就可以用它了
NUM_WORKERS = 3class MyThread(threading.Thread):def __init__(self, input, worktype):self._jobq = inputself._work_type = worktypethreading.Thread.__init__(self)def run(self):while True:if self._jobq.qsize() > 0:self._process_job(self._jobq.get(), self._work_type)else:breakdef _process_job(self, job, worktype):doJob(job, worktype)def doJob(job, worktype):time.sleep(random.random() * 3)print("doing", job, " worktype ", worktype)if __name__ == '__main__':print("begin....")for i in range(NUM_WORKERS * 2):q.put(i)  # 放入到任务队列中去print("job qsize:", q.qsize())for x in range(NUM_WORKERS):MyThread(q, x).start()运行效果：
begin....
job qsize: 6
doing 2  worktype  2
doing 0  worktype  0
doing 1  worktype  1
doing 3  worktype  2
doing 5  worktype  1
doing 4  worktype  0

end
参考：http://www.cnblogs.com/Eva-J/articles/8306047.html

转载于:https://www.cnblogs.com/tielemao/p/9078182.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/353643.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

hibernate 懒加载_Hibernate懒/急加载示例

hibernate 懒加载_Hibernate懒/急加载示例

hibernate 懒加载这篇文章将重点讨论为什么以及如何在应用程序中使用称为LAZY和EAGER加载的概念，以及如何使用Spring的Hibernate模板以EAGER方式加载LAZY实体。 当然，正如标题本身所暗示的那样，我们将通过一个示例来说明这一点。 场景就是这样…
阅读更多...
C++ 关键字typeid

C++ 关键字typeid

转载网址：http://www.cppblog.com/smagle/archive/2010/05/14/115286.aspx 在揭开typeid神秘面纱之前，我们先来了解一下RTTI（Run-Time Type Identification，运行时类型识别），它使程序能够获取由基指针或引用…
阅读更多...
使用Apache Camel进行负载平衡

使用Apache Camel进行负载平衡

在此示例中，我们将向您展示如何使用Apache Camel作为系统的负载平衡器。 在计算机世界中，负载均衡器是一种充当反向代理并在许多服务器之间分配网络或应用程序流量的设备。 负载平衡器用于增加容量（并发用户）和应用程序的可靠性。…
阅读更多...
Java8-Guava实战示例

Java8-Guava实战示例

示例一&#xff1a; 跟示例三对比一下&#xff0c;尽量用示例三 List<InvoiceQueryBean> invoiceQueryBeanList new ArrayList<>(); List<String> invoices Lists.newArrayList(Iterators.transform(invoiceQueryBeanList.iterator(), new Function<Inv…
阅读更多...
java项目构建部署包

java项目构建部署包

博客分类&#xff1a; JAVA Java 工程在生产环境运行时&#xff0c;一般需要构建成一个jar&#xff0c;同时在运行时需要把依赖的jar添加到classpath中去&#xff0c;如果直接运行添加classpath很不方便&#xff0c;比较方便的是创建一个shell脚本。在公司项目中看到把工程代码…
阅读更多...
不错的自学网站合集

不错的自学网站合集

一、网站类1、假期在家如何查找论文资料&#xff1f;只需登录中国图书馆http://t.cn/hYmDq&#xff08;需注册&#xff09;&#xff0c;即可免费下载各种期刊和学位论文2、全球免费开放的电子图书馆http://t.cn/h4hJUf3、给大家推荐个神网站&#xff0c;只要是外文书籍基本上都…
阅读更多...
c++中关于字符串的读入——cin、getline、get、gtes(查询+思考+总结)

c++中关于字符串的读入——cin、getline、get、gtes(查询+思考+总结)

1、cin读入一个字符&#xff1a;char c;cin>>c;2、cin读入一个字符串&#xff1a;char s[10];cin >> s;&#xff08;c风格字符串&#xff09; string str;cin >> str;&#xff08;c的string&#xff09;3、cin.get()读入一个字符&#xff1a;char c;ccin.…
阅读更多...
java文档注释和标题注释_Java注释：探究和解释

java文档注释和标题注释_Java注释：探究和解释

java文档注释和标题注释Java 5 SE的许多出色功能之一是Annotations构造的引入。 注释是一些标签&#xff0c;可以将其插入到程序源代码中&#xff0c;以使用某种工具对其进行处理并使其变得有意义。 注释处理工具通常使用&#xff08;Java 5 SE的&#xff09;Reflection API在J…
阅读更多...
shell 脚本初步，启动可执行 jar 文件

shell 脚本初步，启动可执行 jar 文件

可能很多同学在看到这篇文章的时候是第一次接触 shell 脚本。所以我们首先需要了解什么是 shell 脚本。在 Windows 里我们经常会看到一种扩展名为 .bat 的文件&#xff0c;它称为批处理文件。批处理文件的作用是把许多个命令放在一个文件里&#xff0c;当运行这个文件的时候就执…
阅读更多...
使用Java创建DynamoDB表

使用Java创建DynamoDB表

在这篇文章中&#xff0c;我们将使用java方法在DynamoDB数据库上创建表。 在开始之前&#xff0c;我们需要安装本地dynamodb&#xff0c;因为我们要避免使用dynamodb的任何费用。 有一个以前的岗位上本地dynamodb。 如果您使用docker&#xff0c;则可以找到本地dynamodb映像&a…
阅读更多...
表达式前后缀表达形式 [zz]

表达式前后缀表达形式 [zz]

(2012-09-12 13:08:39) 转载▼标签&#xff1a; 杂谈 转自&#xff1a;http://blog.csdn.net/whatforever/article/details/673853835,15,,80,70,-,*,20,/ //后缀表达方式(((3515)*(80-70))/20&#xff09;25 //中缀表达方式 /,*,,35,15,-,80,70, 2…
阅读更多...
引用:初探Sql Server 执行计划及Sql查询优化

引用:初探Sql Server 执行计划及Sql查询优化

引用:初探Sql Server 执行计划及Sql查询优化 原文:引用:初探Sql Server 执行计划及Sql查询优化初探Sql Server 执行计划及Sql查询优化 收藏MSSQL优化之————探索MSSQL执行计划作者&#xff1a;no_mIss最近总想整理下对MSSQL的一些理解与感悟&#xff0c;却一直没有心思和时间…
阅读更多...
Cities

Cities

问题 C: Cities 时间限制: 1 Sec 内存限制: 128 MB提交: 87 解决: 61[提交][状态][讨论版][命题人:admin]题目描述 There are n cities in Byteland, and the ith city has a value ai. The cost of building a bidirectional road between two cities is the sum of their v…
阅读更多...
spring观察者模式_Spring事件的观察者模式

spring观察者模式_Spring事件的观察者模式

spring观察者模式介绍 观察者模式的本质是“定义对象之间的一对多依赖关系&#xff0c;以便当一个对象改变状态时&#xff0c;其所有依赖关系都会被通知并自动更新”。 GoF。 观察者模式是发布/订阅模式的子集&#xff0c;它允许许多观察者对象查看事件。 可以在不同的情况下使…
阅读更多...
Lombok，自动值和不可变项

Lombok，自动值和不可变项

我喜欢布兰登&#xff08;Brandon &#xff09;在博客文章中比较Project Lombok &#xff0c; AutoValue和Immutables的建议 &#xff0c;而这篇文章试图做到这一点。 我已经简要概述了Project Lombok &#xff0c; AutoValue和Immutables &#xff0c;但是这篇文章有所不同&am…
阅读更多...
linux对于zombie的处理

linux对于zombie的处理

(Linux基础)[僵尸进程处理] 今天在服务器上推送项目的时候&#xff0c;突然发现很卡。就用top查看了一下&#xff0c;果然此事不简单啊。 top - 10:39:16 up 20 days, 23:11, 2 users, load average: 1.13, 1.09, 1.03 Tasks: 204 total, 2 running, 196 sleeping, 1 sto…
阅读更多...
POJ - 1847 Tram（dijkstra）

POJ - 1847 Tram（dijkstra）

题意&#xff1a;有向图有N个点&#xff0c;当电车进入交叉口&#xff08;某点&#xff09;时&#xff0c;它只能在开关指向的方向离开。 如果驾驶员想要采取其他方式&#xff0c;他/她必须手动更换开关。当驾驶员从路口A驶向路口B时&#xff0c;他/她尝试选择将他/她不得不手动…
阅读更多...
用interrupt()中断Java线程

用interrupt()中断Java线程

Javathread 最近在学习Java线程相关的东西&#xff0c;和大家分享一下&#xff0c;有错误之处欢迎大家指正&#xff0e; 假如我们有一个任务如下&#xff0c;交给一个Java线程来执行&#xff0c;如何才能保证调用interrupt()来中断它呢&#xff1f; Java代码 class ATask imple…
阅读更多...
activemq和jms_保证主题，JMS规范和ActiveMQ的消息传递

activemq和jms_保证主题，JMS规范和ActiveMQ的消息传递

activemq和jms最近&#xff0c;一位客户要求我仔细研究ActiveMQ的“持久”消息的实现&#xff0c;它如何应用于主题以及在存在非持久订户的故障转移方案中会发生什么。 我已经了解到&#xff0c;JMS语义规定&#xff0c;即使面对消息代理提供程序故障&#xff0c;也只能保证主题…
阅读更多...
JAVA分代收集机制详解

JAVA分代收集机制详解

Java堆中是JVM管理的最大一块内存空间。主要存放对象实例。在JAVA中堆被分为两块区域&#xff1a;新生代&#xff08;young&#xff09;、老年代&#xff08;old&#xff09;。堆大小新生代老年代&#xff1b;&#xff08;新生代占堆空间的1/3、老年代占堆空间2/3&#xff09;新…
阅读更多...
最新文章

Copyright @ 2022~2023