python 中多线程，锁，重入锁

        线程的有两种使用方法，一种是在函数使用，一种是放在类中使用。

1，在函数中使用多线程

语法如下:

 

 

1	thread.start_new_thread(function,args[,kwargs])

参数说明:

 

 

1 2 3

function-线程函数。 args-传递给线程函数的参数,必须是个tuple类型。 kwargs-可选参数。

下面是一个例子：

 

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def run(num):     print'hi , i am a thread.',num   def main():     threads=[]     foriinrange(5):         t=threading.Thread(target=run,args=(i,))         threads.append(t)         t.start()     fortinthreads:         t.join() if__name__=='__main__':     print'start -->'     main()     print'go here -->'

运行结果：

 

 

1 2 3 4 5 6 7

start--> hi,iamathread.0 hi,iamathread.1 hi,iamathread.2 hi,iamathread.3 hi,iamathread.4 go here-->

 

2，在类中多使用线程

下面是在类中使用线程的示例：

 

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

classMyThread(threading.Thread):     def __init__(self,num):         self.num=num         super(MyThread,self).__init__()     def run(self):         print'i am a thread,',self.num         time.sleep(1)   def main():     threads=[]     foriinrange(5):         t=MyThread(i)         threads.append(t)         t.start()     fortinthreads:         t.join()   if__name__=='__main__':     print'start -->'     main()     print'go here-->

 

• run()，需要重写，编写代码实现所需要的功能。
• getName()，获得线程对象名称
• setName()，设置线程对象名称
• start()，启动线程
• join([timeout])，等待另一线程结束后再运行。
• setDaemon(bool)，设置子线程是否随主线程一起结束，必须在start() 之前调用，默认为False。
• isDaemon()，判断线程是否随主线程一起结束。
• isAlive()，检查线程是否在运行中。

join方法的作用是阻塞主进程（无法执行join以后的语句），主线程等待这个线程结束后，才可以执行下一条指令。多线程多join的情况下，依次执行各线程的join方法，前头一个结束了才能执行后面一个。无参数，则等待到该线程结束，才开始执行下一个线程的join。设置参数后，则等待该线程这么长时间就不管它了（而该线程并没有结束）。不管的意思就是可以执行后面的主进程了。

3，线程同步与互斥锁

线程之所以比进程轻量，其中一个原因就是他们共享内存。也就是各个线程可以平等的访问内存的数据，如果在短时间“同时并行”读取修改内存的数据，很可能造成数据不同步。例如下面的例子：

 

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

var=0 classIncreThread(Thread):     def run(self):         globalvar         print'before,var is ',var         var+=1         print'after,var is ',var   def use_incre_thread():     threads=[]     foriinrange(50):         t=IncreThread()         threads.append(t)         t.start()     fortinthreads:         t.join()     print'After 10 times,var is ',var   if__name__=='__main__':     use_incre_thread()

有一个全局变量var，五十个线程，每个线程对var变量进行加 1 运算，但是当你多运行几次后，发现并不是每次的运行结果都是 50，为什么呢？

在var是 10 的时候，线程t1读取了var，这个时刻cpu将控制权给了另一个线程t2。t2线程读到的var也是 10，t1和t2都把var加到 11，当时我们期望的是t1 t2两个线程使var + 2 变成 12。在这里就有了资源竞争，相同的情况也可能发生在其它的线程间，所以出现了最后的结果小于 50 的情况。

为了避免线程不同步造成数据不同步，可以对资源进行加锁。也就是访问资源的线程需要获得锁，才能访问。threading 模块提供了一个 Lock 功能，修改代码如下：

 

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

var=0 lock=Lock()  #创建锁 classIncreThread(Thread):     def run(self):         globalvar         lock.acquire()  #获取锁         print'before,var is ',var         var+=1         print'after,var is ',var         lock.release()  #释放锁   def use_incre_thread():     threads=[]     foriinrange(50):         t=IncreThread()         threads.append(t)         t.start()     fortinthreads:         t.join()     print'After 10 times,var is ',var   if__name__=='__main__':     use_incre_thread()

虽然线程可以共享内存，但是一个线程不能影响其他线程内的变量（非全局变量）。

4，死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面是一个死锁的例子：

 

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

mutex_a=Lock() mutex_b=Lock()   classMyThread(Thread):     def task_b(self):         ifmutex_a.acquire():             print'thread get a mutex_a',self.name             time.sleep(1)             ifmutex_b.acquire():                 print'get a mutex_b',self.name                 mutex_b.release()             mutex_a.release()       def task_a(self):         ifmutex_b.acquire():             print'thread get a mutex_b',self.name             time.sleep(1)             ifmutex_a.acquire():                 print'get a mutex_a',self.name                 mutex_a.release()             mutex_b.release()       def run(self):         self.task_a()         self.task_b()   if__name__=='__main__':     threads=[MyThread()foriinrange(2)]     print threads     fortinthreads:         t.start()

线程需要执行两个任务，两个任务都需要获取锁，当两个任务得到锁后，就需要等另外锁释放。

5，可重入锁

为了支持在同一线程中多次请求同一资源，python 提供了可重入锁（RLock）。RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。

 

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

mutex=threading.RLock() classMyThread(threading.Thread):     def run(self):         ifmutex.acquire(1):             print'threading gte mutex:',self.name             time.sleep(1)             mutex.acquire()             mutex.release()             mutex.release()   def main():     print'start main threading:'     threads=[MyThread()foriinrange(2)]     fortinthreads:         t.start()     fortinthreads:         t.join()     print'end main threading.'   if__name__=='__main__':             main()

 

6，后台线程

使用多线程默认情况下，当主线程退出之后，即使子线程没有 join，子线程也依然会继续执行。如果希望主线程退出后，其子线程也退出而不再执行，则需要设置子线程为后台线程。python提供了setDaemon方法，将子线程与主线程进行绑定，当主线程退出时子线程的生命也随之结束。

 

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

classMyThread(threading.Thread):     def run(self):         wait_time=random.randrange(1,10)         print'thread %s will wait %s s'%(self.name,wait_time)         time.sleep(wait_time)         time.sleep(30)         print'thread %s finished.'%self.name     def main():     print'start thread:'     foriinrange(3):         t=MyThread()         t.setDaemon(1)         t.start()     print'end thread.'   if__name__=='__main__':     main()

运行结果：

 

 

1 2 3 4 5

start thread: thread Thread-1will wait9s thread Thread-2will wait1s thread Thread-3will wait7s endthread.