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一起进入等锁获取状态。