Python多线程编程——多线程编程中的加锁机制

如果大家对Python中的多线程编程不是很了解，推荐大家阅读之前的两篇文章：

Python多线程编程——多线程基础介绍Python多线程编程——创建线程的两个方法

一、什么是加锁

首先举一个很生活化的例子，比如我们很多人在排队上公共厕所，一旦前面的小明进去了，那么后面的同学理论上就不能再进去了。但是如果后面的同学不知道小明现在在厕所里面，硬是推门进去了，这样机会显得很尴尬。

小明为了不让这么尴尬的局面产生，进入厕所之后，把厕所门锁上。这样后面的同学想要推门进去的时候，就会发现门已经上锁了，便知道里面是有人的。这个时候，后面的同学就会老实在外面等待了。

这是生活中的加锁，那么Python中的加锁是什么样子的呢？其实Python中的加锁场景和刚刚举的上厕所的例子如出一辙。

比如有一个全局变量A，如果有一个线程x正在使用全局变量A（还有可能会修改它），那么其他线程理论上是不能使用变量A的。但是其他线程并不知道x正在使用变量A，可能也会使用它，甚至还很有可能修改它。那么这个时候，就可能会出现问题。

为了不让这些可能的问题出现，线程x在使用变量A的时候，会给它加一把锁，其他线程来使用A的时候，发现A已经被锁上了，就知道其他线程正在使用它，那么这个该线程就会老实地等待其他线程使用完毕，把锁给打开之后，再来使用变量A。

二、为什么要加锁

看了上面的文字，我们也大概知道了为什么要加锁：为了避免可能出现的尴尬问题。这种尴尬问题在Python中的一个直接表现就是产生了“脏数据”。

什么是“脏数据”呢？这里不给大家列出官方的定义，给大家举个实际的例子。

比如现在有两个线程x和y，以及一个全局变量A，A的初始值是0。现在线程x和y做的工作是：循环执行 A = A + 1 100次。示例代码如下：

import threading A = 0 def x(): global A for i in range(100): A = A + 1 print("x执行完成之后，A=" + str(A)) def y(): global A for i in range(100): A = A + 1 print("y执行完成之后，A=" + str(A)) def main(): t1 = threading.Thread(target=x) t2 = threading.Thread(target=y) t1.start() t2.start() if __name__ == '__main__': main()

如果线程x和y分别循环执行100次 A = A + 1 ，那么最终A是等于200。这个看上去很是理所当然，没什么问题。

但是如果如果线程x和y分别循环执行100万次 A = A + 1，最终A还是等于200万吗？这个就不一定了，或者说根本就不会等于200万。

为什么会出现这个情况，就是因为线程x和线程y是同时执行的，产生了脏数据，才会导致A的值没有达到我们理想中的那么多。

最后再补充一点：脏数据具体是怎么产生的呢？

线程x和线程y是同时在执行的，很有可能会出现这个情况：

现在全局变量A=10，x正在执行 A = A + 1，但是还没有完成这一条命令，只完成了A+1，没有将这个值赋给A，也就是说此时的A还是等于10。线程y也来了，他不知道线程x正在执行 A = A + 1 ，于是就一把过A给拉过来，完整地执行了 A = A + 1 ，此时A的值等于11。这个时候，线程x以为自己成功的执行了一次 A = A + 1 ，便不再理会这一次的赋值，开始下一轮循环。

就这样，线程x和线程y分别执行了一次 A = A + 1 ，但是最终A的值只增加了1。在这个过程中那些完成了A+1，但是还没来得及赋给A的数值，就是脏数据。

三、在Python中实现加锁

唠唠叨叨这么多，那么在Python的具体代码中，该如何实现加锁呢？

在Python中实现加锁是非常方便的，主要使用到 threading 库中的Lock类。加锁的思路只有三步：创建锁，加锁，释放锁。这三步思路放大我们的Python代码中，就是下面的三行代码：

gLock = threading.Lock(); # 创建一把锁 gLock.acquire() # 上锁 gLock.release() # 释放锁

就拿上面含有线程x和线程y的例子来说，线程中循环执行100万次 A = A + 1 ，我们使用加锁机制，每次执行这行代码的之前都加上锁，这样另外一个线程就不能再来使用全局变量A，这行代码执行完之后就释放锁，这样另外一个进行就有可能来使用全局变量。具体的实现代码如下：

import threading A = 0 gLock = threading.Lock() def x(): global A for i in range(1000000): gLock.acquire() # 加锁 A = A +1 gLock.release() # 释放锁 print("x执行完成之后，A=" + str(A)) def y(): global A for i in range(1000000): gLock.acquire() # 加锁 A = A +1 gLock.release() # 释放锁 print("y执行完成之后，A=" + str(A)) def main(): t1 = threading.Thread(target=x) t2 = threading.Thread(target=y) t1.start() t2.start() if __name__ == '__main__': main()

如此一来，最后的运行结果如下图。两个线程执行完毕之后，最终的A等于200万。这就说明了加锁的作用了。

最后补充一点：看到上图，你可能会问：为什么线程x执行完毕之后，A的数值不是100万，二是非常接近200万呢？

我们要知道，在上面的例子中，线程x和线程y是同时执行的，而不是线程x执行完成之后再来执行线程y的。所以线程x执行完成之前，其实是两个线程同时执行，同时对A执行加一的操作，所以我们才会看到，线程x执行完成之后，A的值已经非常接近200万。