python thread.join() 详解（详解Python中的Thread线程模块）

threading.Thread

Thread 是threading模块中最重要的类之一               ，可以使用它来创建线程
  
  
  
  
  
  
  
 。有两种方式来创建线程：一种是通过继承Thread类
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  ，重写它的run方法；另一种是创建一个threading.Thread对象














，在它的初始化函数（__init__）中将可调用对象作为参数传入  
  
  
  
  
  
  
 。下面分别举例说明
 


 


 


 


 


 


 


 
。

先来看看通过继承threading.Thread类来创建线程的例子：

#coding=gbk importthreading,time,random count=0 classCounter(threading.Thread): def__init__(self,lock,threadName): @summary:初始化对象
 
 
 
 
 
 
 
。 @paramlock:琐对象   
   
   
   
   
   
   
  。 @paramthreadName:线程名称
 

 

 

 

 

 

 

 
。 super(Counter,self).__init__(name=threadName) #注意：一定要显式的调用父类的初始化函数

 

 

 

 

 

 

 
。 self.lock=lock defrun(self): @summary:重写父类run方法 
  
  
  
  
  
  
  
，在线程启动后执行该方法内的代码                。 globalcount self.lock.acquire() foriinxrange(10000): count=count+1 self.lock.release() lock=threading.Lock() foriinrange(5): Counter(lock,"thread-"+str(i)).start() time.sleep(2) #确保线程都执行完毕 printcount

在代码中
  
  
  
  
  
  
  
 ，我们创建了一个Counter类
 


 


 


 


 


 


 


 ，它继承了threading.Thread
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
。初始化函数接收两个参数 
 
 
 
 
 
 
 
，一个是琐对象
   
   
   
   
   
   
   
 ，另一个是线程的名称














。在Counter中
 

 

 

 

 

 

 

 ，重写了从父类继承的run方法 

 

 

 

 

 

 

 
，run方法将一个全局变量逐一的增加10000                       。

在接下来的代码中               ，创建了五个Counter对象

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 ，分别调用其start方法 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
。最后打印结果






















。这里要说明一下run方法 和start方法: 它们都是从Thread继承而来的














，run()方法将在线程开启后执行                       ，可以把相关的逻辑写到run方法中（通常把run方法称为活动[Activity]               。）；start()方法用于启动线程  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
。

再看看另外一种创建线程的方法：

importthreading,time,random count=0 lock=threading.Lock() defdoAdd(): @summary:将全局变量count逐一的增加10000














。 globalcount,lock lock.acquire() foriinxrange(10000): count=count+1 lock.release() foriinrange(5): threading.Thread(target=doAdd,args=(),name=thread-+str(i)).start() time.sleep(2) #确保线程都执行完毕 printcount

在这段代码中
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ，我们定义了方法doAdd






















，它将全局变量count 逐一的增加10000
  
  
  
  
  
  
  
 。然后创建了5个Thread对象               ，把函数对象doAdd 作为参数传给它的初始化函数
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  ，再调用Thread对象的start方法














，线程启动后将执行doAdd函数  
  
  
  
  
  
  
 。这里有必要介绍一下threading.Thread类的初始化函数原型：

def__init__(self,group=None,target=None,name=None,args=(),kwargs={})

　　参数group是预留的 
  
  
  
  
  
  
  
，用于将来扩展；

　　参数target是一个可调用对象（也称为活动[activity]）
  
  
  
  
  
  
  
 ，在线程启动后执行；

　　参数name是线程的名字
 


 


 


 


 


 


 


 
。默认值为“Thread-N“
 


 


 


 


 


 


 


 ，N是一个数字
 
 
 
 
 
 
 
。

　　参数args和kwargs分别表示调用target时的参数列表和关键字参数   
   
   
   
   
   
   
  。

Thread类还定义了以下常用方法与属性：

Thread.getName() Thread.setName() Thread.name

用于获取和设置线程的名称
 

 

 

 

 

 

 

 
。

Thread.ident

获取线程的标识符

 

 

 

 

 

 

 
。线程标识符是一个非零整数 
 
 
 
 
 
 
 
，只有在调用了start()方法之后该属性才有效
   
   
   
   
   
   
   
 ，否则它只返回None                。

Thread.is_alive()

Thread.isAlive()

判断线程是否是激活的（alive）
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
。从调用start()方法启动线程
 

 

 

 

 

 

 

 ，到run()方法执行完毕或遇到未处理异常而中断 这段时间内 

 

 

 

 

 

 

 
，线程是激活的














。

Thread.join([timeout])

调用Thread.join将会使主调线程堵塞               ，直到被调用线程运行结束或超时                       。参数timeout是一个数值类型

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 ，表示超时时间














，如果未提供该参数                       ，那么主调线程将一直堵塞到被调线程结束 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
。下面举个例子说明join()的使用：

importthreading,time defdoWaiting(): printstartwaiting:,time.strftime(%H:%M:%S) time.sleep(3) printstopwaiting,time.strftime(%H:%M:%S) thread1=threading.Thread(target=doWaiting) thread1.start() time.sleep(1) #确保线程thread1已经启动 printstartjoin thread1.join() #将一直堵塞
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ，直到thread1运行结束






















。 printendjoin threading.RLock和threading.Lock

在threading模块中






















，定义两种类型的琐：threading.Lock和threading.RLock               。它们之间有一点细微的区别               ，通过比较下面两段代码来说明：

importthreading lock=threading.Lock() #Lock对象 lock.acquire() lock.acquire() #产生了死琐  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
。 lock.release() lock.release() importthreading rLock=threading.RLock() #RLock对象 rLock.acquire() rLock.acquire() #在同一线程内
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  ，程序不会堵塞














。 rLock.release() rLock.release()

这两种琐的主要区别是：RLock允许在同一线程中被多次acquire
  
  
  
  
  
  
  
 。而Lock却不允许这种情况  
  
  
  
  
  
  
 。注意：如果使用RLock














，那么acquire和release必须成对出现 
  
  
  
  
  
  
  
，即调用了n次acquire
  
  
  
  
  
  
  
 ，必须调用n次的release才能真正释放所占用的琐
 


 


 


 


 


 


 


 
。

threading.Condition

可以把Condiftion理解为一把高级的琐
 


 


 


 


 


 


 


 ，它提供了比Lock, RLock更高级的功能 
 
 
 
 
 
 
 
，允许我们能够控制复杂的线程同步问题
 
 
 
 
 
 
 
。threadiong.Condition在内部维护一个琐对象（默认是RLock）
   
   
   
   
   
   
   
 ，可以在创建Condigtion对象的时候把琐对象作为参数传入   
   
   
   
   
   
   
  。Condition也提供了acquire, release方法
 

 

 

 

 

 

 

 ，其含义与琐的acquire, release方法一致 

 

 

 

 

 

 

 
，其实它只是简单的调用内部琐对象的对应的方法而已
 

 

 

 

 

 

 

 
。Condition还提供了如下方法(特别要注意：这些方法只有在占用琐(acquire)之后才能调用               ，否则将会报RuntimeError异常

 

 

 

 

 

 

 
。)：

Condition.wait([timeout]):

wait方法释放内部所占用的琐

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 ，同时线程被挂起














，直至接收到通知被唤醒或超时（如果提供了timeout参数的话）                。当线程被唤醒并重新占有琐的时候                       ，程序才会继续执行下去
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
。

Condition.notify():

唤醒一个挂起的线程（如果存在挂起的线程）














。注意：notify()方法不会释放所占用的琐                       。

Condition.notify_all()

Condition.notifyAll()

唤醒所有挂起的线程（如果存在挂起的线程） 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
。注意：这些方法不会释放所占用的琐






















。

现在写个捉迷藏的游戏来具体介绍threading.Condition的基本使用               。假设这个游戏由两个人来玩
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ，一个藏(Hider)






















，一个找(Seeker)  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
。游戏的规则如下：1. 游戏开始之后               ，Seeker先把自己眼睛蒙上
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  ，蒙上眼睛后














，就通知Hider；2. Hider接收通知后开始找地方将自己藏起来 
  
  
  
  
  
  
  
，藏好之后
  
  
  
  
  
  
  
 ，再通知Seeker可以找了； 3. Seeker接收到通知之后
 


 


 


 


 


 


 


 ，就开始找Hider














。Hider和Seeker都是独立的个体 
 
 
 
 
 
 
 
，在程序中用两个独立的线程来表示
   
   
   
   
   
   
   
 ，在游戏过程中
 

 

 

 

 

 

 

 ，两者之间的行为有一定的时序关系 

 

 

 

 

 

 

 
，我们通过Condition来控制这种时序关系
  
  
  
  
  
  
  
 。

#----Condition #----捉迷藏的游戏 importthreading,time classHider(threading.Thread): def__init__(self,cond,name): super(Hider,self).__init__() self.cond=cond self.name=name defrun(self): time.sleep(1) #确保先运行Seeker中的方法 self.cond.acquire() #b printself.name+:我已经把眼睛蒙上了 self.cond.notify() self.cond.wait() #c #f printself.name+:我找到你了~_~ self.cond.notify() self.cond.release() #g printself.name+:我赢了 #h classSeeker(threading.Thread): def__init__(self,cond,name): super(Seeker,self).__init__() self.cond=cond self.name=name defrun(self): self.cond.acquire() self.cond.wait() #a#释放对琐的占用               ，同时线程挂起在这里

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 ，直到被notify并重新占 有琐  
  
  
  
  
  
  
 。 #d printself.name+:我已经藏好了














，你快来找我吧 self.cond.notify() self.cond.wait() #e #h self.cond.release() printself.name+:被你找到了                       ，哎~~~ cond=threading.Condition() seeker=Seeker(cond,seeker) hider=Hider(cond,hider) seeker.start() hider.start()

threading.Event

Event实现与Condition类似的功能
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ，不过比Condition简单一点
 


 


 


 


 


 


 


 
。它通过维护内部的标识符来实现线程间的同步问题
 
 
 
 
 
 
 
。（threading.Event和.NET中的System.Threading.ManualResetEvent类实现同样的功能   
   
   
   
   
   
   
  。）

Event.wait([timeout])

堵塞线程






















，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）
 

 

 

 

 

 

 

 
。

Event.set()

将标识位设为Ture

Event.clear()

将标识伴设为False

 

 

 

 

 

 

 
。

Event.isSet()

判断标识位是否为Ture                。

下面使用Event来实现捉迷藏的游戏(可能用Event来实现不是很形象)

#----Event #----捉迷藏的游戏 importthreading,time classHider(threading.Thread): def__init__(self,cond,name): super(Hider,self).__init__() self.cond=cond self.name=name defrun(self): time.sleep(1) #确保先运行Seeker中的方法 printself.name+:我已经把眼睛蒙上了 self.cond.set() time.sleep(1) self.cond.wait() printself.name+:我找到你了~_~ self.cond.set() printself.name+:我赢了 classSeeker(threading.Thread): def__init__(self,cond,name): super(Seeker,self).__init__() self.cond=cond self.name=name defrun(self): self.cond.wait() printself.name+:我已经藏好了               ，你快来找我吧 self.cond.set() time.sleep(1) self.cond.wait() printself.name+:被你找到了
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  ，哎~~~ cond=threading.Event() seeker=Seeker(cond,seeker) hider=Hider(cond,hider) seeker.start() hider.start()

threading.Timer

threading.Timer是threading.Thread的子类














，可以在指定时间间隔后执行某个操作
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
。下面是Python手册上提供的一个例子：

defhello(): print"hello,world" t=Timer(3,hello) t.start() #3秒钟之后执行hello函数














。

threading模块中还有一些常用的方法没有介绍：

threading.active_count()

threading.activeCount()

获取当前活动的(alive)线程的个数                       。

threading.current_thread()

threading.currentThread()

获取当前的线程对象（Thread object） 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
。

threading.enumerate()

获取当前所有活动线程的列表






















。

threading.settrace(func)

设置一个跟踪函数 
  
  
  
  
  
  
  
，用于在run()执行之前被调用               。

threading.setprofile(func)

设置一个跟踪函数
  
  
  
  
  
  
  
 ，用于在run()执行完毕之后调用  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
。