Lock对象

原语锁(互斥锁)是一个同步原语,状态是"已锁定"或者"未锁定"之一.两个方法acquire()和release()用于修改锁的状态.如果状态为已锁定,
尝试获取锁将被阻塞,直到锁被释放为止.如果有多个线程等待获取锁,当锁被释放时,只有一个线程能获取它,等待线程获得锁的顺序没有定义.

使用下面的构造函数可以创建新的Lock实例:

Lock()
创建新的Lock对象,初始状态为未锁定 Lock实例lock支持一下方法 lock.acquire([blocking])
获取锁,如果有必要,需要阻塞到锁释放为止.如果提供blocking参数并将它设为False,当无法获取锁时立即返回False,
如果成功获取锁则返回True. lock.release()
释放一个锁.当锁处于未锁定状态时,或者从与原本调用acquire()方法的线程不同的线程调用此方法,将出现错误
# 未加锁,Windows下运行不会出现混乱,在Linux下运行就会发行结果出现混乱

import threading
import time num = def show():
global num
time.sleep()
num +=
print(num) for i in range():
t = threading.Thread(target=show)
t.start() print('thread stop')
Linux下的结果(多运行几遍就会发现结果混乱)
# 加锁
import threading
import time clock = threading.Lock()
num = def show():
clock.acquire()
global num
time.sleep()
num +=
print(num)
clock.release() for i in range():
t = threading.Thread(target=show)
t.start() print('thread stop')

Rlock对象

可重入锁是一个类似于Lock对象的同步原语,但同一个线程可以多次获取它。这允许拥有锁的线程执行嵌套的acquire()和release()操作。在这种
情况下,只有对外面的release()操作才能将锁重置为未锁定状态。

使用以下的构造函数可以创建一个新的RLock对象:

RLock()
创建新的可重入锁对象。RLock对象rlock支持一下方法。 rlock.acquire([blocking])
获取锁,如果有必要,需要阻塞到锁被释放为止。如果没有线程拥有锁,它将被锁定,而且递归级别被置为1.如果此线程已经拥有锁,锁的递归级别加1,
而且函数立即返回。 rlock.release()
通过减少锁的递归级别来释放它。如果在减值后递归级别为0,锁将被重置为未锁定状态。否则,锁将保持以锁定状态。只能由目前拥有锁的线程来调用此函数。

在使用诸如Lock,RLcok或Semphore之类的锁原语时,必须多加小心。锁的错误管理经常导致死锁或竞争条件。依赖的代码应该保证出现异常时正确地释放锁。
典型的代码如下:

 try:
lock.acquire()
# 关键部分
statements
...
finally:
lock.release() # 另外,所有种类的锁还支持上下文管理协议(写起来更简洁些) with lock:
# 关键部分
# with语句自动获取锁,并且在控制流离开上下文时自动释放锁
# 此外,编写代码时一般应该避免同时获取多个锁例如:
with lock_A:
# 关键部分
statements ...
with lock_B:
# B的关键部分 ...

这通常很容易导致应用程序神秘死锁。尽管有几种策略可以避免出现这种情况(如分层锁定),但最好在编写代码时就避免这种做法

信号量

信号量是一个基于计数器的同步原语,每一次调用acquire()方法时此计数器减1,每次调用release()方法时此计数器加1.如果计数器为0,acquire()方法将会阻塞,
直到其他线程调用release()方法为止。

Semaphore([value])
创建一个新的信号量。value是计数器的初始值。如果省略此参数,计数器的值将被置为1. Semaphore实例s支持一下方法 s.acquire([blocking])
获取信号量。如果进入时内部计数器大于0,此方法将把它的值减1,然后立即返回。如果它的值为0,此方法将阻塞,知道另一个线程调用release()方法为止。
blocking参数的行为与Lock和RLock对象中描述的相同
s.release()
通过将内部计数器的值加1来释放一个信号量。如果计数器为0,而且另一个线程正在等待,该线程将被唤醒。如果有多个线程正在等待,只能从它的acquire()
调用返回其中一个。线程释放的顺序并不确定 BoundedSemaphore([value])
创建一个新的信号量。Value是计数器的初始值。如果省略此参数,计数器的值将被置为1.BounderSemaphore的工作方式与Semaphore完全相同,
但release()操作的次数不能超过acquire()操作的次数

信号量与互斥锁之间的微妙差别在于:信号量可以用于发信号。例如,可以从不同的线程调用acquire()和release()方法,以便在生产者和消费者线程之间进行通信。

 import threading
import time
produced = threading.Semaphore(3)
consumed = threading.Semaphore(2) def producer():
for i in range(10):
consumed.acquire()
time.sleep(3)
print('-----------------', time.ctime())
consumed.release() def consumer():
for j in range(10,20):
produced.acquire()
time.sleep(3)
print('=================', time.ctime())
consumed.release() for i in range(20):
t1 = threading.Thread(target=producer)
t2 = threading.Thread(target=consumer)
t1.start()
t2.start()

运行结果

 ----------------- Fri Dec 14 16:11:08 2018
================= Fri Dec 14 16:11:08 2018
----------------- Fri Dec 14 16:11:08 2018
================= Fri Dec 14 16:11:08 2018
================= Fri Dec 14 16:11:08 2018
----------------- Fri Dec 14 16:11:11 2018
----------------- Fri Dec 14 16:11:11 2018
----------------- Fri Dec 14 16:11:11 2018
----------------- Fri Dec 14 16:11:11 2018
----------------- Fri Dec 14 16:11:11 2018
----------------- Fri Dec 14 16:11:14 2018

事件

事件用于在线程之间通信。一个线程发出“事件”信号,一个或多个其他线程等待它,Event实例管理着一个内部标志,可以使用set()方法将它置为True,或者
使用clear()方法将它重置为False。wait()方法将阻塞,直到标志为True

Event()
创建新的Event实例,并将内部标志置为False。Event实例e支持一下方法 e.is_set()
只有当内部标志为True时才返回True。在老式代码中此方法叫isSet() e.set()
内部标志为True。等待它变为True的所有线程都将被唤醒 e.clear()
将内部标志重置为False e.wait([timeout])
阻塞直到内部标志为True。如果进入时内部标志为True,此方法将立即返回。否则它将阻塞,直到另一个线程调用set()方法将标志置为True,或者直到出现可选的
超时。timeout是一个浮点数,用于指定以秒为单位的超时期限
 import threading
import time event = threading.Event() def chihuoguo():
# 等待事件,进入等待阻塞状态
print('%s 进入准备状态' % threading.currentThread().getName())
time.sleep(1)
event.wait()
# 收到事件后进入运行状态
print('%s 开始运行' % threading.currentThread().getName()) # 设置线程组
threads = [] # 创建新线程
thread1 = threading.Thread(target=chihuoguo, name='one')
thread2 = threading.Thread(target=chihuoguo, name='two') # 添加到线程组
threads.append(thread1)
threads.append(thread2) # 开启线程
for thread in threads:
thread.start() time.sleep(0.1)
# 发送事件通知
print('event start')
event.set()

使用event.clear()

 import threading
import time event = threading.Event() def chihuoguo():
for i in range(1, 5):
# 等待事件,进入等待阻塞状态
print('%s %s 进入准备状态' % (threading.currentThread().getName(), i))
time.sleep(1)
event.wait() if i == 3:
event.clear()
# 收到事件后进入运行状态
print('%s %s 开始运行' % (threading.currentThread().getName(), i)) # 设置线程组
threads = [] # 创建新线程
thread1 = threading.Thread(target=chihuoguo, name='one')
thread2 = threading.Thread(target=chihuoguo, name='two') # 添加到线程组
threads.append(thread1)
threads.append(thread2) # 开启线程
for thread in threads:
thread.start() time.sleep(0.1) # event.clear()
# 发送事件通知
print('event start')
event.set()

尽管Event对象可用于给其他线程发信号,但不应该使用它们来实现在生成者/消费者问题中十分典型的通知。例如,应该避免写出下面这样的代码

 evt = threading.Event()

 def producer():
while True:
# 生产者
...
evt.signal() def consumer():
while True:
# 一个等待项
evt.wait()
# 消费项
...
# 清除事件并再次等待
evt.clear()

这段代码并不可靠,因为在evt.wait()和evt.clear()操作之间,生产者可能产生了一个新项。但是,通过清除事件,在生产者创建一个新项之前,消费者可能看不到
这个新项。最好的情况是,程序将经过一段很短的停滞,对项的处理被莫名其妙推迟了。最坏的情况是,由于事件信号丢失,整个程序将挂起。要解决这类问题最好使用
条件变量

Python多线程笔记(二)的更多相关文章

  1. Python 学习笔记二

    笔记二 :print 以及基本文件操作 笔记一已取消置顶链接地址 http://www.cnblogs.com/dzzy/p/5140899.html 暑假只是快速过了一遍python ,现在起开始仔 ...

  2. python学习笔记(二)、字符串操作

    该一系列python学习笔记都是根据<Python基础教程(第3版)>内容所记录整理的 1.字符串基本操作 所有标准序列操作(索引.切片.乘法.成员资格检查.长度.最小值和最大值)都适用于 ...

  3. Python面试笔记二

    一.算法 1.归并排序 2.快速排序 3.算法复杂度 4.哈希表数据结构 二.数据库 1.设计一个用户关注系统的数据库表 1.设计一个用户关注系统的数据库表,写三个相关的SQL语句两张表,一张user ...

  4. python多线程学习二

    本文希望达到的目标: 多线程同步原语:互斥锁 多线程队列queue 线程池threadpool 一.多线程同步原语:互斥锁 在多线程代码中,总有一些特定的函数或者代码块不应该被多个线程同时执行,通常包 ...

  5. python多线程(二)

    开启线程的两种方式 #方式一from threading import Threadimport timedef sayhi(name):   time.sleep(2)   print('%s sa ...

  6. Python学习笔记二

    ---恢复内容开始--- 一. python几种数据类型的比较. 从以下几个方面比较: 1. 是否可变. 不可变类型:变量的值可以发生变化,id也变了,相当于创建了一个新的对象,所以一修改值,id就变 ...

  7. Python学习笔记(二)

    标识符和关键字 1,邮箱的Python标识符是任意长度的非空字符序列(引导字符+后续字符.) python标识符必须符合两条规则--标识符区分大小写 (1)只要是unicode编码字母都可以充当引导字 ...

  8. Python基础笔记(二)

    1. List和Tuple List和Tuple是Python的内置的数据类型,区别在于可变和不可变,List用[]表示,Tuple用()表示,它们之间可以相互转换: # List to Tuple ...

  9. python学习笔记(二):python数据类型

    上一篇博客写了python的入门和简单流程控制,这次写python的数据类型和各种数据类型的内置方法.一.数据类型是什么鬼?计算机顾名思义就是可以做数学计算的机器,因此,计算机程序理所当然地可以处理各 ...

随机推荐

  1. RAP2 前后端开发利器搭建

    RAP2 是一个api管理系统,前后端协作开发的利器. 在线体验地址http://rap2.taobao.org Web接口管理工具,开源免费,接口自动化,MOCK数据自动生成,自动化测试,企业级管理 ...

  2. ALV报表——选择屏幕变量赋值

    ABAP选择屏幕变量赋值 运行效果: 代码: *&---------------------------------------------------------------------* ...

  3. (未完成)ARM-linux 移植 SDL

    ref : https://blog.csdn.net/u012075739/article/details/24877639   2.      交叉编译SDL 编译SDL前先要编译其依赖库 tsl ...

  4. React Hooks中父组件中调用子组件方法

    React Hooks中父组件中调用子组件方法 使用到的hooks-- useImperativeHandle,useRef /* child子组件 */ // https://reactjs.org ...

  5. 服务篇:我的第一WebService应用

    一.我的第一个Webservice应用 1.新建一个空项目 2.添加新项,加入asmx,并再浏览器浏览 3.添加一个aspx网页 4.右键引用→添加服务引用→高级→添加Web引用,输入再浏览器浏览的a ...

  6. java 读取文件流

    搬运自速学堂:https://www.sxt.cn/Java_jQuery_in_action/ten-iqtechnology.html JAVA中IO流体系: 四大IO抽象类 ·InputStre ...

  7. 图片上传怎么用File接受文件

    xl_echo编辑整理,欢迎转载,转载请声明文章来源.欢迎添加echo微信(微信号:t2421499075)交流学习. 百战不败,依不自称常胜,百败不颓,依能奋力前行.——这才是真正的堪称强大!! - ...

  8. SAP-参数(条件表)配置教程–GS01/GS02/GS03

    转载:http://www.baidusap.com/abap/others/2849 在SAP开发中,某段代码运行可能需要满足某个条件,通常解决办法有两种:一种是在代码中写死限制条件,此种方式当限制 ...

  9. 多线程之NSOperation简介

    在iOS开发中,为了提升用户体验,我们通常会将操作耗时的操作放在主线程之外的线程进行处理.对于正常的简单操作,我们更多的是选择代码更少的GCD,让我们专注于自己的业务逻辑开发.NSOperation在 ...

  10. flask-sqlalchemy使用及数据迁移

    flask-sqlalchemy是flask框架在sqlalchemy基础上改造的一个orm框架 现在有两个实体Article文章和Category分类 一个分类下可能有多篇文章 相关示例: 项目相关 ...