python线程threading,python thread类

　　穿线。线

　　Thread是线程模块中最重要的类之一，可以用来创建线程。创建线程有两种方法：一种是继承Thread类，重写其run方法；另一个是创建一个线程。Thread对象，并在其初始化函数(__init__)中将可调用对象作为参数传递。下面是一些例子。

　　让我们看看通过继承线程创建线程的例子。线程类别：

　　#编码=gbk

　　导入线程，时间，随机

　　计数=0

　　classCounter(线程。螺纹):

　　def__init__(self，lock，threadName):

　　 @summary:初始化该对象。

　　@paramlock:琐碎对象。

　　@paramthreadName:线程名。

　　超级(专柜，自己)。__init__(name=threadName)

　　#注意：一定要显式调用父类的初始化函数。

　　self.lock=lock

　　defrun(self):

　　@summary:重写父类run方法，在线程启动后执行该方法中的代码。

　　全球计数

　　self.lock.acquire()

　　传真号码(10000):

　　计数=计数1

　　self.lock.release()

　　锁=线程。锁定()

　　(5):

　　Counter(lock， thread- str(i))。开始()

　　时间.睡眠(2)

　　#确保所有线程都已执行

　　Printcount代码，我们创建一个计数器类，它继承了线程。Thread初始化函数接收两个参数，一个是普通对象，另一个是线程的名称。在计数器中，重写从父类继承的run方法，run方法将一个全局变量逐个增加10000。

　　在下面的代码中，创建了五个计数器对象，并分别调用了它们的start方法。最后，打印结果。这里说明一下run方法和start方法3360都是继承自Thread的。线程打开后会执行run()方法，相关逻辑可以写入run方法(通常称为[Activity])。);start()方法用于启动一个线程。

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

　　导入线程，时间，随机

　　计数=0

　　锁=线程。锁定()

　　defdoAdd():

　　@summary:将全局变量计数逐个增加10000。

　　全局计数，锁定

　　lock.acquire()

　　传真号码(10000):

　　计数=计数1

　　lock.release()

　　(5):

　　穿线。线程(target=doAdd，args=()，名称

　　='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={})

　　参数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():
　　print'startwaiting:',time.strftime('%H:%M:%S')
　　time.sleep(3)
　　print'stopwaiting',time.strftime('%H:%M:%S')
　　thread1=threading.Thread(target=doWaiting)
　　thread1.start()
　　time.sleep(1)
　　#确保线程thread1已经启动
　　print'startjoin'
　　thread1.join()
　　#将一直堵塞，直到thread1运行结束。
　　print'endjoin'
　　threading.RLock和threading.Lock

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()

　　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()

　　Event实现与Condition类似的功能，不过比Condition简单一点。它通过维护内部的标识符来实现线程间的同步问题。（threading.Event和.NET中的System.Threading.ManualResetEvent类实现同样的功能。）

Event.wait([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.Thread的子类，可以在指定时间间隔后执行某个操作。下面是Python手册上提供的一个例子：

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

　　threading.active_count()

　　threading.activeCount()

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

　　threading.current_thread()

　　threading.currentThread()

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

　　threading.enumerate()

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

　　threading.settrace(func)

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

　　threading.setprofile(func)

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

　　threading模块的内容很多。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。