Python线程编程之Thread详解
一、线程编程(thread)
1、线程基本概念
1.1、什么事线程
- 线程被称为轻量级的进程
- 线程也可以使用计算机多核资源,是多任务编程方式
- 线程是系统分配内核的最小单元
- 线程可以理解为进程的分支任务
1.2、线程特征
- 一个进程中可以包含多个线程
- 线程也是一个运行行为,消耗计算机资源
- 一个线程中的所有线程共享这个进程的资源
- 多个线程之间的运行互不影响各自运行
- 线程的创建和销毁消耗资源远小于进程
- 各个线程也有自己的id等特征
二、threading模块创建线程
1、创建线程对象
from threading import thread t = thread() 功能: 创建线程对象 参数: target 绑定线程函数 args 元组 给线程函数位置传参 kwargs 字典 给线程函数键值传参
2、 启动线程
t.start()
3、 回收线程
t.join([timeout])
4、代码演示
""" thread1.py 线程基础使用 步骤: 1. 封装线程函数 2.创建线程对象 3.启动线程 4.回收线程 """ import os from threading import thread from time import sleep a = 1 # 线程函数 def music(): for i in range(3): sleep(2) print('播放:黄河大合唱 %s' % os.getpid()) global a print("a,",a) a = 1000 # 创建线程对象 t = thread(target=music) # 启动线程 t.start() for i in range(3): sleep(1) print('播放:beauty love %s' % os.getpid()) # 回收线程 t.join() print('程序结束') print("a,", a)
5、线程对象属性
1.t.name
线程名称
2.t.setname()
设置线程名称
3.t.getname()
获取线程名称
4.t.is_alive()
查看线程是否在生命周期
5.t.daemon
设置主线程和分支线程退出分支线程也退出.要在start前设置 通常不和join 一起使用
6.代码演示
""" thread3.py 线程属性演示 """ from threading import thread from time import sleep def fun(): sleep(3) print('线程属性测试') t = thread(target=fun, name='ceshi') # 主线程退出分支线程也退出 必须在start前使用 与join 没有意义 t.setdaemon(true) t.start() print(t.getname()) t.setname('tedu') print('is alive:', t.is_alive()) print('daemon', t.daemon)
6、自定义线程类
1.创建步骤
1.继承thread类
2.重写 __init__方法添加自己的属性 使用super加载父类属性
3.重写run方法
2.使用方法
1.实例化对象
2.调佣start自动执行run方法
3.调佣join回收线程
代码演示
""" 自定义线程类例子 """ from threading import thread # 自定义线程类 class threadclass(thread): # 重写父类 init def __init__(self, *args, **kwargs): self.attr = args[0] # 加载父类init super().__init__() # 假设需要很多步骤完成功能 def f1(self): print('1') def f2(self): print(2) # 重写run 逻辑调佣 def run(self): self.f1() self.f2() t = threadclass() t.start() t.join()
7、一个很重要的练习 我很多不懂
from threading import thread from time import sleep, ctime class mythread(thread): def __init__(self, group=none, target=none, name=none, args=(), kwargs=none, *, daemon=none): super().__init__() self.fun = target self.args = args self.kwargs = kwargs def run(self): self.fun(*self.args, **self.kwargs) def player(sec, song): for i in range(3): print("playing %s : %s" % (song, ctime())) sleep(sec) t = mythread(target=player, args=(3,), kwargs={'song': '量量'}) t.start() t.join()
8、线程间通信
1.通信方法
1.线程间使用全局遍历进行通信
2.共享资源争夺
1.共享资源:多个进程或者线程都可以操作的资源称为共享资源,对共享资源的操作代码段称为临界区
2.影响:对公共资源的无序操作可能会带来数据的混乱,或者操作错误.此时往往需要同步互斥机制协调操作顺序
3.同步互斥机制
1.同步:同步是一种协作关系,为完成操作,多进程或者线程形成一种协调,按照必要的步骤有序执行操作
2.互斥:互斥是一种制约关系,当一个进程或者线程占有资源时,会进行加锁处理,此时其它进程线程就无法操作该资源,直到解锁后才能操作
## 9.线程同步互斥方法
1. 线程event 代码演示
from threading import event # 创建线程event对象 e = event() # 阻塞等待e被set e.wait([timeout]) # 设置e, 使wait结束阻塞 e.set() # 使e回到未被设置状态 e.clear() # 查看当前e是否被设置 e.is_set()
""" event 线程互斥方法演示 """ from threading import event, thread s = none # 用于通信 e = event() def yzr(): print('杨子荣前来拜山头') global s s = '天王盖地虎' e.set() #操作完共享资源 e设置 t = thread(target=yzr) t.start() print('说对口令就是自己人') e.wait() #阻塞等待 e.set() if s == '天王盖地虎': print('宝塔镇河妖') print('确认过眼神,你是对的人') e.clear() else: print('打死他...') t.join() print('程序结束')
2. 线程锁 lock代码演示
from threading import lock lock = lock()创建锁对象 lock.acquire() 上锁 如果lock已经上锁再调用会阻塞 lock.release() 解锁 with lock: 上锁 .... .... with 代码块解锁自动解锁
""" thread_lock 线程锁演示 """ from threading import thread, lock a = b = 0 lock = lock() def value(): while true: # 上锁 lock.acquire() print('a=%d,b=%d' % (a, b)) if a != b else print('a不等于b') # 解锁 lock.release() t = thread(target=value) t.start() while true: # with 开始上锁 with lock: a += 1 b += 1 # with 解锁 自动解锁 t.join() print('程序结束')
10、死锁及其处理
1.定义
死锁是指两个或者两个以上的线程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,他们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁.
2.图解
3. 死锁产生条件
死锁发生的必要条件
- 互斥条件:指线程对所分配到的资源进行排它性使用,即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源,则请求者只能等待,直至占有资源的进程用毕释放。
- 请求和保持条件:指线程已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它进程占有,此时请求线程阻塞,但又对自己已获得的其它资源保持不放。
- 不剥夺条件:指线程已获得的资源,在未使用完之前,不能被剥夺,只能在使用完时由自己释放,通常cpu内存资源是可以被系统强行调配剥夺的。
- 环路等待条件:指在发生死锁时,必然存在一个线程——资源的环形链,即进程集合{t0,t1,t2,···,tn}中的t0正在等待一个t1占用的资源;t1正在等待t2占用的资源,……,tn正在等待已被t0占用的资源。
- 死锁的产生原因
简单来说造成死锁的原因可以概括成三句话:
- 当前线程拥有其他线程需要的资源
- 当前线程等待其他线程已拥有的资源
- 都不放弃自己拥有的资源
如何避免死锁
死锁是我们非常不愿意看到的一种现象,我们要尽可能避免死锁的情况发生。通过设置某些限制条件,去破坏产生死锁的四个必要条件中的一个或者几个,来预防发生死锁。预防死锁是一种较易实现的方法。但是由于所施加的限制条件往往太严格,可能会导致系统资源利用率。
4.死锁代码演示
from time import sleep from threading import thread, lock # 交易类 class account: def __init__(self, _id, balance, lock): # 用户 self._id = _id # 存款 self.balance = balance # 锁 self.lock = lock # 取钱 def withdraw(self, amount): self.balance -= amount # 存钱 def deposit(self, amount): self.balance += amount # 余额 def get_balance(self): return self.balance tom = account('tom', 5000, lock()) alex = account('alex', 8000, lock()) def transfer(from_, to, amount): # 锁住自己账户 if from_.lock.acquire(): # 账户减少 from_.withdraw(amount) sleep(0.5) if to.lock.acquire(): to.deposit(amount) to.lock.release() from_.lock.release() print('转账完成 %s给%s转账%d' % (from_._id, to._id, amount)) # transfer(tom, alex, 1000) t1 = thread(target=transfer, args=(tom, alex, 2000)) t2 = thread(target=transfer, args=(alex, tom, 3500)) t1.start() t2.start() t1.join() t2.join() print('程序结束')
python线程gil
1.python线程的gil问题 (全局解释器锁)
什么是gil :由于python解释器设计中加入了解释器锁,导致python解释器同一时刻只能解释执行一个线程,大大降低了线程的执行效率。
导致后果: 因为遇到阻塞时线程会主动让出解释器,去解释其他线程。所以python多线程在执行多阻塞高延迟io时可以提升程序效率,其他情况并不能对效率有所提升。
gil问题建议
- 尽量使用进程完成无阻塞的并发行为
- 不使用c作为解释器 (java c#)
总结:
在无阻塞状态下,多线程程序和单线程程序执行效率几乎差不多,甚至还不如单线程效率。但是多进程运行相同内容却可以有明显的效率提升。
本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!