python 实现线程之间的通信
前言:因为GIL的限制,python的线程是无法真正意义上并行的。相对于异步编程,其性能可以说不是一个等量级的。为什么我们还要学习多线程编程呢,虽然说异步编程好处多,但编程也较为复杂,逻辑不容易理解,学习成本和维护成本都比较高。毕竟我们大部分人还是适应同步编码的,除非一些需要高性能处理的地方采用异步。
首先普及下进程和线程的概念:
进程:进程是操作系统资源分配的基本单位。
线程:线程是任务调度和执行的基本单位。
一个应用程序至少一个进程,一个进程至少一个线程。
两者区别:同一进程内的线程共享本进程的资源如内存、I/O、cpu等,但是进程之间的资源是独立的。
一、多线程
python 可以通过 thread 或 threading 模块实现多线程,threading 相比 thread 提供了更高阶、更全面的线程管理。我们下文主要以 threading 模块介绍多线程的基本用法。
import threading
import time class thread(threading.Thread):
def __init__(self, threadname):
threading.Thread.__init__(self, name='线程' + threadname) def run(self):
print('%s:Now timestamp is %s'%(self.name,time.time())) threads = []
for a in range(int(5)): # 线程个数
threads.append(thread(str(a)))
for t in threads: # 开启线程
t.start()
for t in threads: # 阻塞线程
t.join()
print('END') 输出:
#线程3:Now timestamp is 1557386184.7574518
#线程2:Now timestamp is 1557386184.7574518
#线程0:Now timestamp is 1557386184.7574518
#线程1:Now timestamp is 1557386184.7574518
#线程4:Now timestamp is 1557386184.7582724
#END
start() 方法开启子线程。运行多次 start() 方法代表开启多个子线程。
join() 方法用来阻塞主线程,等待子线程执行完成。举个例子,主线程A创建了子线程B,并使用了 join() 方法,主线程A在 join() 处就被阻塞了,等待子线程B完成后,主线程A才能执行 print('END')。如果没有使用 join() 方法,主线程A创建子线程B后,不会等待子线程B,直接执行 print('END'),如下:
import threading
import time class thread(threading.Thread):
def __init__(self, threadname):
threading.Thread.__init__(self, name='线程' + threadname) def run(self):
time.sleep(1)
print('%s:Now timestamp is %s'%(self.name,time.time())) threads = []
for a in range(int(5)): # 线程个数
threads.append(thread(str(a)))
for t in threads: # 开启线程
t.start()
# for t in threads: # 阻塞线程
# t.join()
print('END') 输出:
#END
#线程0:Now timestamp is 1557386321.376941
#线程3:Now timestamp is 1557386321.377937
#线程1:Now timestamp is 1557386321.377937
#线程2:Now timestamp is 1557386321.377937
#线程4:Now timestamp is 1557386321.377937
二、线程之间的通信
1.threading.Lock()
如果多个线程对某一资源同时进行修改,可能会存在不可预知的情况。为了修改数据的正确性,需要把这个资源锁住,只允许线程依次排队进去获取这个资源。当线程A操作完后,释放锁,线程B才能进入。如下脚本是开启多个线程修改变量的值,但输出结果每次都不一样。
import threading money = 0
def Order(n):
global money
money = money + n
money = money - n class thread(threading.Thread):
def __init__(self, threadname):
threading.Thread.__init__(self, name='线程' + threadname)
self.threadname = int(threadname) def run(self):
for i in range(1000000):
Order(self.threadname) t1 = thread('')
t2 = thread('')
t1.start()
t2.start()
t1.join()
t2.join()
print(money)
接下来我们用 threading.Lock() 锁住这个变量,等操作完再释放这个锁。lock.acquire() 给资源加一把锁,对资源处理完成之后,lock.release() 再释放锁。以下脚本执行结果都是一样的,但速度会变慢,因为线程只能一个个的通过。
import threading money = 0
def Order(n):
global money
money = money + n
money = money - n class thread(threading.Thread):
def __init__(self, threadname):
threading.Thread.__init__(self, name='线程' + threadname)
self.threadname = int(threadname) def run(self):
for i in range(1000000):
lock.acquire()
Order(self.threadname)
lock.release()
# print('%s:Now timestamp is %s'%(self.name,time.time())) lock = threading.Lock()
t1 = thread('')
t2 = thread('')
t1.start()
t2.start()
t1.join()
t2.join()
print(money)
2.threading.Rlock()
用法和 threading Lock() 一致,区别是 threading.Rlock() 允许多次锁资源,acquire() 和 release() 必须成对出现,也就是说加了几把锁就得释放几把锁。
lock = threading.Lock()
# 死锁
lock.acquire()
lock.acquire()
print('...')
lock.release()
lock.release() rlock = threading.RLock()
# 同一线程内不会阻塞线程
rlock.acquire()
rlock.acquire()
print('...')
rlock.release()
rlock.release()
3.threading.Condition()
threading.Condition() 可以理解为更加高级的锁,比 Lock 和 Rlock 的用法更高级,能处理一些复杂的线程同步问题。threading.Condition() 创建一把资源锁(默认是Rlock),提供 acquire() 和 release() 方法,用法和 Rlock 一致。此外 Condition 还提供 wait()、Notify() 和 NotifyAll() 方法。
wait():线程挂起,直到收到一个 Notify() 通知或者超时(可选参数),wait() 必须在线程得到 Rlock 后才能使用。
Notify() :在线程挂起的时候,发送一个通知,让 wait() 等待线程继续运行,Notify() 也必须在线程得到 Rlock 后才能使用。 Notify(n=1),最多唤醒 n 个线程。
NotifyAll() :在线程挂起的时候,发送通知,让所有 wait() 阻塞的线程都继续运行。
举例说明下 Condition() 使用
import threading,time def TestA():
cond.acquire()
print('李白:看见一个敌人,请求支援')
cond.wait()
print('李白:好的')
cond.notify()
cond.release() def TestB():
time.sleep(2)
cond.acquire()
print('亚瑟:等我...')
cond.notify()
cond.wait()
print('亚瑟:我到了,发起冲锋...') if __name__=='__main__':
cond = threading.Condition()
testA = threading.Thread(target=TestA)
testB = threading.Thread(target=TestB)
testA.start()
testB.start()
testA.join()
testB.join() 输出
#李白:看见一个敌人,请求支援
#亚瑟:等我...
#李白:好的
#亚瑟:我到了,发起冲锋...
4.threading.Event()
threading.Event() 原理是在线程中立了一个 Flag ,默认值是 False ,当一个或多个线程遇到 event.wait() 方法时阻塞,直到 Flag 值 变为 True 。threading.Event() 通常用来实现线程之间的通信,使一个线程等待其他线程的通知 ,把 Event 传递到线程对象中。
event.wait() :阻塞线程,直到 Flag 值变为 True
event.set() :设置 Flag 值为 True
event.clear() :修改 Flag 值为 False
event.isSet() : 仅当 Flag 值为 True 时返回
下面这个例子,主线程启动子线程后 sleap 2秒,子线程因为 event.wait() 被阻塞。当主线程醒来后执行 event.set() ,子线程才继续运行,两者输出时间差 2s。
import threading
import datetime,time class thread(threading.Thread):
def __init__(self, threadname):
threading.Thread.__init__(self, name='线程' + threadname)
self.threadname = int(threadname) def run(self):
event.wait()
print('子线程运行时间:%s'%datetime.datetime.now()) if __name__ == '__main__':
event = threading.Event()
t1 = thread('')
#启动子线程
t1.start()
print('主线程运行时间:%s'%datetime.datetime.now())
time.sleep(2)
# Flag设置成True
event.set()
t1.join() 输出
#主线程运行时间:2019-05-30 15:51:49.690872
#子线程运行时间:2019-05-30 15:51:51.691523
5.其他方法
threading.active_count():返回当前存活的线程对象的数量
threading.current_thread():返回当前线程对象
threading.enumerate():返回当前所有线程对象的列表
threading.get_ident():返回线程pid
threading.main_thread():返回主线程对象
python 实现线程之间的通信的更多相关文章
- 基础学习day12--多线程一线程之间的通信和常用方法
一.线程之间的通信 1.1.线程之间的通信方法 多个线程在处理统一资源,但是任务却不同,这时候就需要线程间通信. 等待/唤醒机制涉及的方法: 1. wait():让线程处于冻结状态,被wa ...
- iOS边练边学--多线程介绍、NSThread的简单实用、线程安全以及线程之间的通信
一.iOS中的多线程 多线程的原理(之前多线程这块没好好学,之前对多线程的理解也是错误的,这里更正,好好学习这块) iOS中多线程的实现方案有以下几种 二.NSThread线程类的简单实用(直接上代码 ...
- VC中利用多线程技术实现线程之间的通信
当前流行的Windows操作系统能同时运行几个程序(独立运行的程序又称之为进程),对于同一个程序,它又可以分成若干个独立的执行流,我们称之为线程,线程提供了多任务处理的能力.用进程和线程的观点来研究软 ...
- vc 基于对话框多线程编程实例——线程之间的通信
vc基于对话框多线程编程实例——线程之间的通信 实例:
- Handler实现线程之间的通信-下载文件动态更新进度条
1. 原理 每一个线程对应一个消息队列MessageQueue,实现线程之间的通信,可通过Handler对象将数据装进Message中,再将消息加入消息队列,而后线程会依次处理消息队列中的消息. 2. ...
- Java多线程编程-线程之间的通信
转载自:这里 学习了基础的线程知识 看到了 线程之间的通信 线程之间有哪些通信方式呢? 1.同步 这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信. public ...
- Java学习笔记46(多线程三:线程之间的通信)
多个线程在处理同一个资源,但是线程的任务却不相同,通过一定的手段使各个线程能有效地利用资源, 这种手段即:等待唤醒机制,又称作线程之间的通信 涉及到的方法:wait(),notify() 示例: 两个 ...
- java线程之间的通信
1.常用的方法 sleep() 该线程进入等待状态,不释放锁 wait() 该线程进入等待状态,释放锁 notify() 随机唤醒一个线程 notifyAll() 唤醒全部线程 getName() 获 ...
- java之线程(线程的创建方式、java中的Thread类、线程的同步、线程的生命周期、线程之间的通信)
CPU:10核 主频100MHz 1核 主频 3GHz 那么哪一个CPU比较好呢? CPU核不是越多越好吗?并不一定.主频用于衡量GPU处理速度的快慢,举个例子10头牛运送货物快还是1架飞机运 ...
随机推荐
- js获得子节点, 获得tab转json值
//提取表格的值,JSON格式 function GetTableData(table) { var tableData = new Array(); //创建数组 alert("行数:&q ...
- CAD动态绘制带面积周长的圆(com接口)
CAD绘制图像的过程中,画圆的情况是非常常见的,用户可以在控件视区点取任意一点做为圆心,再动态点取半径绘制圆. 主要用到函数说明: _DMxDrawX::DrawCircle 绘制一个圆.详细说明如下 ...
- 【JAVA】简陋的学生信息管理系统
因为之前写了一个学生信息管理系统,但还是处于命令行界面,不美观,于是打算做一个完整的界面出来. 在网上查阅资料后发现C++本身是不支持图形化界面的(可以使用第三方的Qt来做) 权衡之下还是选择了JAV ...
- linux修改mysql表结构
增加字段: alter table [tablename] add [字段名] [字段类型] first(首位); alter table [tablename] add [字段名] [字段类型] a ...
- Beetl学习总结(4)——Web集成
4.1. Web提供的全局变量 Web集成模块向模板提供web标准的变量,做如下说明 request 中的所有attribute.在模板中可以直接通过attribute name 来引用,如在cont ...
- 给sunpinyin加速
因为sunpinyin词库一大就会卡,因此需要自己添加一个脚本给sunpinyin加速. 加速的原理就是把词库添加到内存,现在内存都这么大,根本不在乎这么几兆,当然输入体验更重要啦- 首先先建一个脚本 ...
- POJ - 3541 - Given a string…
Given a string… Time Limit: 10000MS Memory Limit: 65536K Total Submissions: 1819 Accepted: 390 C ...
- springCloud学习-服务的注册与发现(Eureka)
1.小记 这段时间有空,把springcloud的知识整理一下,好记性不如烂笔头,也让自己对springcloud有个清晰的认识.此次的整理记录主要借鉴了这位大佬的博客 https://blog.cs ...
- SecureCRT 的使用技巧
SecureCRT 支持 SSH1,SSH2,Telnet,RLogin,Serial,和 TAPI 协议, 一般用来登录Linux服务器进行跨系统操作,也可代替 超级终端,进行串口 调试. 1.串口 ...
- Spring中Bean的作用域差别
我觉得servlet和spring交叉起来,理解得快. Bean的作用域中,prototype和singleton作用域效果不一样,前者每次都会有新的实例,而后者始终一个实例 . 所以,java.ut ...