python递归锁与信号量

递归锁

一把大锁在加一把小锁。

import threading

import time

def run1():

    print("grab the first part data")

    lock.acquire()

    global num

    num += 1

    lock.release()

    return num

def run2():

    print("grab the second part data")

    lock.acquire()

    global num2

    num2 += 1

    lock.release()

    return num2

def run3():

    lock.acquire()

    res = run1()

    print('--------between run1 and run2-----')

    res2 = run2()

    lock.release()

    print(res, res2)

if __name__ == '__main__':

    num, num2 = 0, 0

    lock = threading.Lock()

    for i in range(10):

        t = threading.Thread(target=run3)

        t.start()

while threading.active_count() != 1:

    print(threading.active_count())

else:

    print('----all threads done---')

    print(num, num2)

过程分享:
1、启动10个线程，每个线程都执行run3。

2、run3中先加了一个锁，然后执行run1。

3、run1中也加了一个锁，计算完成后解锁返回数据。执行run2。

4、run2中同样加了一个锁，计算完成后解锁打印run1,run2返回值。

5、最后打印num1、num2。

需要注意的是在执行过程中是有两把锁的，一个run3，一个run1或者run2。

运行结果：

11

11

11

11

11

11

11

11

# 程序进入死循环

死循环的原因是解锁的时候 钥匙拿错了导致进程退不出来，解决死锁就是要使用递归锁。

threading.Lock() 改为 threading.RLock()

import threading

import time

def run1():

    print("grab the first part data")

    lock.acquire()

    global num

    num += 1

    lock.release()

    return num

def run2():

    print("grab the second part data")

    lock.acquire()

    global num2

    num2 += 1

    lock.release()

    return num2

def run3():

    lock.acquire()

    res = run1()

    print('--------between run1 and run2-----')

    res2 = run2()

    lock.release()

    print(res, res2)

if __name__ == '__main__':

    num, num2 = 0, 0

    lock = threading.RLock()

    for i in range(1):

        t = threading.Thread(target=run3)

        t.start()

while threading.active_count() != 1:

    print(threading.active_count())

else:

    print('----all threads done---')

    print(num, num2)

运行结果

grab the first part data

--------between run1 and run2-----

grab the second part data

1 1

----all threads done---

1 1

实现原理：

解锁的时候找对应的钥匙。

信号量

互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。简单的说就是互斥锁同一时间只能要一个线程修改数据，信号量同一时间可以让多个线程修改数据。信号量可以挂多吧锁。

import threading,time

def run(n):

    semaphore.acquire()

    time.sleep(1)

    print("run the thread: %s\n" %n)

    semaphore.release()

if __name__ == '__main__':

    num= 0

    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行

    for i in range(20):

        t = threading.Thread(target=run,args=(i,))

        t.start()

while threading.active_count() != 1:

    pass #print threading.active_count()

else:

    print('----all threads done---')

    print(num)

每一个进程结束了就重新添加一个新的进去。