Python 多线程编程(二):threading 模块中 Lock 类的用法详解

大概可以这样讲，多线程最难的是如何正确协调各个线程修改同一份数据。

以卖票的例子作为说明。

买票有多个窗口，假设有 3 个好了，窗口之间共享一个票池，每个窗口都可以买票直到票池里面没有票可以卖。

不难写出下面的代码。

import threading
import random

class WindowThread(threading.Thread):

    def __init__(self,name):
        threading.Thread.__init__(self,name=name)
        self.name = name
        self.tickts = 0

    def run(self):
        global tickt_count

        while tickt_count > 0:

            print('%s notice:There has %d tickts remain ' %(self.name,tickt_count))

            if tickt_count > 2:
                number = random.randint(1,2)
            else:
                number = 1

            tickt_count -= number
            self.tickts += number

            print('%s have buy %d tickt,the remain tickt\'t count is %d .Already buy %d \n'
                  % (self.name, number, tickt_count, self.tickts))

        print('%s notice:There is no tickt can sold! Already sold %d'%(self.name,self.tickts))


tickt_count = 10

window1 = WindowThread('window1')
window2 = WindowThread('window2')
window3 = WindowThread('window3')

window1.start()
window2.start()
window3.start()
window1.join()
window2.join()
window3.join()

print('tickt count ',tickt_count)

假设有 3 个窗口，总共有 10 张票。

在每个窗口排队购票时，窗口会告诉你当前还剩多少票。

if tickt_count > 2:
      number = random.randint(1,2)
   else:
      number = 1

tickt_count -= number
self.tickts += number

 

每个人最多购买 2 张票，如果票池当中只剩下 1 张票时，那么也只能购买一张票了。

tickt_count 是票池里面剩余的票的数量。
tickts 是每个窗口已经卖出的数量。

购买结束后，要更新票池里面剩余票的数量，和更新本窗口卖出去的票数。

最后，所有的窗口无票可卖的时候，结束。然后打印 票池里面的票数，理论上应该是 0，因为票已经卖光了。

我们看结果运行如何：

window1 notice:There has 10 tickts remain 
window2 notice:There has 10 tickts remain 
window1 have buy 2 tickt,the remain tickt't count is 8 .Already buy 2 
window2 have buy 1 tickt,the remain tickt't count is 7 .Already buy 1 

window1 notice:There has 7 tickts remain 
window1 have buy 2 tickt,the remain tickt't count is 5 .Already buy 4 

window1 notice:There has 5 tickts remain 
window1 have buy 1 tickt,the remain tickt't count is 4 .Already buy 5 

window1 notice:There has 4 tickts remain 
window1 have buy 1 tickt,the remain tickt't count is 3 .Already buy 6 

window1 notice:There has 3 tickts remain 
window1 have buy 2 tickt,the remain tickt't count is 1 .Already buy 8 

window3 notice:There has 1 tickts remain 
window1 notice:There has 1 tickts remain 
window1 have buy 1 tickt,the remain tickt't count is 0 .Already buy 9 

window1 notice:There is no tickt can sold! Already sold 9
window3 have buy 1 tickt,the remain tickt't count is -1 .Already buy 1 

window3 notice:There is no tickt can sold! Already sold 1

window2 notice:There is no tickt can sold! Already sold 1
tickt count  -1

多运行几次，可以发现一个现象，那就是结果不正确。

3 个窗口的卖出的总数对不上。

最后显示 tickt count 为 -1，而不是 0，这显然不符合我们的预期。

Q:为什么会这样呢？

A:因为我们没有保护好多个线程之间，共享的数据。

Q:怎么能解决呢？

A:Lock 机制可以解决

什么是 Lock?

Lock 中文称为锁，是一种初级的多线程同步的手段。

Lock 有 locked 和 unlocked 两种状态,而这两中状态之间是可以转换的.

• 当 Lock 是 unlocked 状态时候，某个线程调用 acquire() 可以获取这个 Lock,并且将 Lock将状态转换成 locked 状态，并且线程不会阻塞。
• 但当 Lock 是 locked 状态时，某个线程调用 acquire() 会阻塞自己，直到其他的线程将 Lock 的状态变成 unlocked。
• 当 Lock 是 locked 状态时，调用 release() 方法，可以释放一个 Lock，这样其它线程就可以获取这个 Lock 了。
• 但当 Lock 是 unlocked 状态时，某个线程调用 release(),程序会抛出 RuntimeError 异常。

所以，acquire() 和 release() 方法在单个线程当中都是成对使用的。

有效利用 Lock 的状态转换机制，就可以避免多个线程同时修改同一份数据。

于是，我们可以进行代码的改写。

import threading
import random


class WindowThread(threading.Thread):

    def __init__(self,name,lock):
        threading.Thread.__init__(self,name=name)
        self.name = name
        self.tickts = 0
        self.lock = lock

    def run(self):
        global tickt_count

        while tickt_count > 0:

            print('%s notice:There has %d tickts remain ' %(self.name,tickt_count))

            self.lock.acquire()
            if tickt_count > 0:
                if tickt_count > 2:
                    number = random.randint(1,2)
                else:
                    number = 1
                tickt_count -= number
                self.tickts += number

                print('%s have buy %d tickt,the remain tickt\'t count is %d .Already buy %d \n'
                      % (self.name, number, tickt_count, self.tickts))
            self.lock.release()


        print('%s notice:There is no tickt can sold! Already sold %d'%(self.name,self.tickts))


tickt_count = 10

lock = threading.Lock()

window1 = WindowThread('window1',lock)
window2 = WindowThread('window2',lock)
window3 = WindowThread('window3',lock)

window1.start()
window2.start()
window3.start()
window1.join()
window2.join()
window3.join()

print('tickt count ',tickt_count)

还是 3 个线程，但代码少许不一样。

lock = threading.Lock()

window1 = WindowThread('window1',lock)
window2 = WindowThread('window2',lock)
window3 = WindowThread('window3',lock)

3 个线程共用 1 个 Lock 对象。

self.lock.acquire()
if tickt_count > 0:
   if tickt_count > 2:
       number = random.randint(1,2)
   else:
       number = 1
   tickt_count -= number
   self.tickts += number

   print('%s have buy %d tickt,the remain tickt\'t count is %d .Already buy %d \n'
         % (self.name, number, tickt_count, self.tickts))
self.lock.release()

进行关键数据操作的时候，用 Lock 锁起来，这样每次就只能一个线程对 tickt_count 数量进行修改。

最终程序结果运行如下：

window1 notice:There has 10 tickts remain 
window1 have buy 1 tickt,the remain tickt't count is 9 .Already buy 1 

window2 notice:There has 9 tickts remain 
window1 notice:There has 9 tickts remain 
window2 have buy 1 tickt,the remain tickt't count is 8 .Already buy 1 

window3 notice:There has 8 tickts remain 
window2 notice:There has 8 tickts remain 
window2 have buy 2 tickt,the remain tickt't count is 6 .Already buy 3 

window2 notice:There has 6 tickts remain 
window3 have buy 2 tickt,the remain tickt't count is 4 .Already buy 2 

window3 notice:There has 4 tickts remain 
window2 have buy 2 tickt,the remain tickt't count is 2 .Already buy 5 

window2 notice:There has 2 tickts remain 
window1 have buy 1 tickt,the remain tickt't count is 1 .Already buy 2 

window1 notice:There has 1 tickts remain 
window3 have buy 1 tickt,the remain tickt't count is 0 .Already buy 3 

window3 notice:There is no tickt can sold! Already sold 3
window2 notice:There is no tickt can sold! Already sold 5
window1 notice:There is no tickt can sold! Already sold 2
tickt count  0

　　

可以多试几次，窗口卖出的票数都是可以对的上号的，并且最终票池里面的数量是 0，不会发生之前出现为 -1 的情况。

所以，自此我们就通过引入 Lock 同步机制，进行了一个很简单化的多线程编码示例。

默认情况，当一个 Lock 是 locked 状态时调用 acquire()，会阻塞线程本身。

但我们可以设置不阻塞，或者是阻塞指定时间。

#不阻塞
lock.acquire(False)

#阻塞指定时间，如 3 秒钟,当然 python3 的版本才有这个功能

lock.acquire(timeout=3)