python的线程锁机制

 

 

线程与锁

 

 

请求锁定 -- 进入锁定池等待 -- 获取锁 --- 已锁定 --- 释放锁

 

 

锁

Lock()

 

Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。

可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

构造方法：
Lock()

实例方法：
acquire([timeout]): 使线程进入同步阻塞状态，尝试获得锁定。
release(): 释放锁。使用前线程必须已获得锁定，否则将抛出异常。

 

实例程序:

 

#!/usr/bin/env python



import threading

import time



data = 0

lock = threading.Lock()



def fun():

        global data

        print "%s acquire lock..."% threading.currentThread().getName()

        if lock.acquire(): #等待获取锁，如果获取成功，开始锁定并进行操作

                print '%s get the lock.' % threading.currentThread().getName()

                data += 1

                print data

                time.sleep(1)

                print '%s release lock...' % threading.currentThread().getName()

                lock.release() #释放锁



t1 = threading.Thread(target=fun)

t2 = threading.Thread(target=fun)

t3 = threading.Thread(target=fun)

t1.start()

t2.start()

t3.start()

 

以上代码，当线程t1锁释放后线程t2才能进行锁定。同样道理，等t2锁释放，t3才能进行锁定，但t2、t3会在t1一起进入等待锁获取状态。

 

 

重入锁

RLock()

RLock（可重入锁）是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数。

可以认为RLock包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将+1/-1，为0时锁处于未锁定状态。

构造方法：
RLock()

实例方法：
acquire([timeout])/release(): 跟Lock差不多。

 

实例程序:

 

#!/usr/bin/env python



import threading

import time



data = 0

lock = threading.RLock()



def fun():

        global data

        print "%s acquire lock..."% threading.currentThread().getName()

        if lock.acquire(): #等待获取锁，如果获取成功，开始锁定并进行操作

                print '%s get the lock.' % threading.currentThread().getName()

                data += 1

                print data

                time.sleep(2)

                print '%s get the lock again.' % threading.currentThread().getName()

                if lock.acquire(): #再次获取并，如果获取成功，开始锁定并进行操作

                        data += 1

                        print data

                        time.sleep(2)

                print '%s release lock...' % threading.currentThread().getName()

                lock.release() #释放锁

                time.sleep(1)

                print '%s release lock again...' % threading.currentThread().getName()

                lock.release() #释放锁



t1 = threading.Thread(target=fun)

t2 = threading.Thread(target=fun)

t3 = threading.Thread(target=fun)

t1.start()

t2.start()

t3.start()

 

 

 

以上代码，当线程t1两次请求的锁都释放后线程t2才能进行锁定。同样道理，等t2两次请求的锁释放后，t3才能进行锁定，但t2、t3会同t1一起进入等锁获取状态。