Python线程编程中的Thread该如何理解(python,thread,开发技术)

一、线程编程(Thread)

1、线程基本概念

1.1、什么事线程

• 线程被称为轻量级的进程

• 线程也可以使用计算机多核资源,是多任务编程方式

• 线程是系统分配内核的最小单元

• 线程可以理解为进程的分支任务

1.2、线程特征

• 一个进程中可以包含多个线程

• 线程也是一个运行行为,消耗计算机资源

• 一个线程中的所有线程共享这个进程的资源

• 多个线程之间的运行互不影响各自运行

• 线程的创建和销毁消耗资源远小于进程

• 各个线程也有自己的ID等特征

二、threading模块创建线程

1、创建线程对象

fromthreadingimportThreadt=Thread()功能:创建线程对象参数:target绑定线程函数 args元组给线程函数位置传参 kwargs字典给线程函数键值传参

2、 启动线程

t.start()

3、 回收线程

t.join([timeout])

4、代码演示

"""thread1.py线程基础使用步骤:1.封装线程函数2.创建线程对象3.启动线程4.回收线程"""importosfromthreadingimportThreadfromtimeimportsleepa=1#线程函数defmusic():foriinrange(3):sleep(2)print('播放:黄河大合唱%s'%os.getpid())globalaprint("a,",a)a=1000#创建线程对象t=Thread(target=music)#启动线程t.start()foriinrange(3):sleep(1)print('播放:beautylove%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线程属性演示"""fromthreadingimportThreadfromtimeimportsleepdeffun():sleep(3)print('线程属性测试')t=Thread(target=fun,name='ceshi')#主线程退出分支线程也退出必须在start前使用与join没有意义t.setDaemon(True)t.start()print(t.getName())t.setName('Tedu')print('isalive:',t.is_alive())print('daemon',t.daemon)

6、自定义线程类

1.创建步骤

1.继承Thread类

2.重写 __init__方法添加自己的属性 使用super加载父类属性

3.重写run方法

2.使用方法

1.实例化对象

2.调佣start自动执行run方法

3.调佣join回收线程

代码演示

"""自定义线程类例子"""fromthreadingimportThread#自定义线程类classThreadClass(Thread):#重写父类initdef__init__(self,*args,**kwargs):self.attr=args[0]#加载父类initsuper().__init__()#假设需要很多步骤完成功能deff1(self):print('1')deff2(self):print(2)#重写run逻辑调佣defrun(self):self.f1()self.f2()t=ThreadClass()t.start()t.join()

7、一个很重要的练习 我很多不懂

fromthreadingimportThreadfromtimeimportsleep,ctimeclassMyThread(Thread):def__init__(self,group=None,target=None,name=None,args=(),kwargs=None,*,daemon=None):super().__init__()self.fun=targetself.args=argsself.kwargs=kwargsdefrun(self):self.fun(*self.args,**self.kwargs)defplayer(sec,song):foriinrange(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 代码演示

fromthreadingimportEvent#创建线程event对象e=Event()#阻塞等待e被sete.wait([timeout])#设置e,使wait结束阻塞e.set()#使e回到未被设置状态e.clear()#查看当前e是否被设置e.is_set()

"""event线程互斥方法演示"""fromthreadingimportEvent,Threads=None#用于通信e=Event()defyzr():print('杨子荣前来拜山头')globalss='天王盖地虎'e.set()#操作完共享资源e设置t=Thread(target=yzr)t.start()print('说对口令就是自己人')e.wait()#阻塞等待e.set()ifs=='天王盖地虎':print('宝塔镇河妖')print('确认过眼神,你是对的人')e.clear()else:print('打死他...')t.join()print('程序结束')

2. 线程锁 Lock代码演示

fromthreadingimportLocklock=Lock()创建锁对象lock.acquire()上锁如果lock已经上锁再调用会阻塞lock.release()解锁withlock:上锁........with代码块解锁自动解锁

"""thread_lock线程锁演示"""fromthreadingimportThread,Locka=b=0lock=Lock()defvalue():whileTrue:#上锁lock.acquire()print('a=%d,b=%d'%(a,b))ifa!=belseprint('a不等于b')#解锁lock.release()t=Thread(target=value)t.start()whileTrue:#with开始上锁withlock:a+=1b+=1#with解锁自动解锁t.join()print('程序结束')

10、死锁及其处理

1.定义

死锁是指两个或者两个以上的线程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,他们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁.

2.图解

3. 死锁产生条件

死锁发生的必要条件

• 互斥条件：指线程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。

• 请求和保持条件：指线程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求线程阻塞，但又对自己已获得的其它资源保持不放。

• 不剥夺条件：指线程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放,通常CPU内存资源是可以被系统强行调配剥夺的。

• 环路等待条件：指在发生死锁时，必然存在一个线程——资源的环形链，即进程集合{T0，T1，T2，···，Tn}中的T0正在等待一个T1占用的资源；T1正在等待T2占用的资源，……，Tn正在等待已被T0占用的资源。

• 死锁的产生原因

简单来说造成死锁的原因可以概括成三句话：

• 当前线程拥有其他线程需要的资源

• 当前线程等待其他线程已拥有的资源

• 都不放弃自己拥有的资源

如何避免死锁

死锁是我们非常不愿意看到的一种现象，我们要尽可能避免死锁的情况发生。通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。预防死锁是一种较易实现的方法。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率。

4.死锁代码演示

fromtimeimportsleepfromthreadingimportThread,Lock#交易类classAccount:def__init__(self,_id,balance,lock):#用户self._id=_id#存款self.balance=balance#锁self.lock=lock#取钱defwithdraw(self,amount):self.balance-=amount#存钱defdeposit(self,amount):self.balance+=amount#余额defget_balance(self):returnself.balanceTom=Account('Tom',5000,Lock())Alex=Account('Alex',8000,Lock())deftransfer(from_,to,amount):#锁住自己账户iffrom_.lock.acquire():#账户减少from_.withdraw(amount)sleep(0.5)ifto.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#）

在无阻塞状态下，多线程程序和单线程程序执行效率几乎差不多，甚至还不如单线程效率。但是多进程运行相同内容却可以有明显的效率提升。