通俗易懂：说说 Python 里的线程安全、原子操做

首发于微信公众号：Python编程时光

在线博客地址：http://python.iswbm.com/en/latest/c01/c01_42.html

---

在并发编程时，若是多个线程访问同一资源，咱们须要保证访问的时候不会产生冲突，数据修改不会发生错误，这就是咱们常说的 线程安全 。

那什么状况下，访问数据时是安全的？什么状况下，访问数据是不安全的？如何知道你的代码是否线程安全？要如何访问数据才能保证数据的安全？

本篇文章会一一回答你的问题。

1. 线程不安全是怎样的？

要搞清楚什么是线程安全，就要先了解线程不安全是什么样的。

好比下面这段代码，开启两个线程，对全局变量 number 各自增 10万次，每次自增 1。

from threading import Thread, Lock

number = 0

def target():
    global number
    for _ in range(1000000):
        number += 1

thread_01 = Thread(target=target)
thread_02 = Thread(target=target)
thread_01.start()
thread_02.start()

thread_01.join()
thread_02.join()

print(number)

正常咱们的预期输出结果，一个线程自增100万，两个线程就自增 200 万嘛，输出确定为 2000000 。

可事实却并非你想的那样，无论你运行多少次，每次输出的结果都会不同，而这些输出结果都有一个特色是，都小于 200 万。

如下是执行三次的结果

1459782
1379891
1432921

这种现象就是线程不安全，究其根因，实际上是咱们的操做 number += 1 ，不是原子操做，才会致使的线程不安全。

2. 什么是原子操做？

原子操做（atomic operation），指不会被线程调度机制打断的操做，这种操做一旦开始，就一直运行到结束，中间不会切换到其余线程。

它有点相似数据库中的 事务。

在 Python 的官方文档上，列出了一些常见原子操做

L.append(x)
L1.extend(L2)
x = L[i]
x = L.pop()
L1[i:j] = L2
L.sort()
x = y
x.field = y
D[x] = y
D1.update(D2)
D.keys()

而下面这些就不是原子操做

i = i+1
L.append(L[-1])
L[i] = L[j]
D[x] = D[x] + 1

像上面的我使用自增操做 number += 1，其实等价于 number = number + 1，能够看到这种能够拆分红多个步骤（先读取相加再赋值），并不属于原子操做。

这样就致使多个线程同时读取时，有可能读取到同一个 number 值，读取两次，却只加了一次，最终致使自增的次数小于预期。

当咱们仍是没法肯定咱们的代码是否具备原子性的时候，能够尝试经过 dis 模块里的 dis 函数来查看

当咱们执行这段代码时，能够看到 number += 1 这一行代码，由两条字节码实现。

• BINARY_ADD ：将两个值相加
• STORE_GLOBAL： 将相加后的值从新赋值

每一条字节码指令都是一个总体，没法分割，他实现的效果也就是咱们所说的原子操做。

当一行代码被分红多条字节码指令的时候，就表明在线程线程切换时，有可能只执行了一条字节码指令，此时若这行代码里有被多个线程共享的变量或资源时，而且拆分的多条指令里有对于这个共享变量的写操做，就会发生数据的冲突，致使数据的不许确。

为了对比，咱们从上面列表的原子操做拿一个出来也来试试，是否是真如官网所说的原子操做。

这里我拿字典的 update 操做举例，代码和执行过程以下图

从截图里能够看到，info.update(new) 虽然也分为好几个操做

• LOAD_GLOBAL：加载全局变量
• LOAD_ATTR： 加载属性，获取 update 方法
• LOAD_FAST：加载 new 变量
• CALL_FUNCTION：调用函数
• POP_TOP：执行更新操做

但咱们要知道真正会引导数据冲突的，其实不是读操做，而是写操做。

上面这么多字节码指令，写操做都只有一个（POP_TOP），所以字典的 update 方法是原子操做。

3. 实现人工原子操做

在多线程下，咱们并不能保证咱们的代码都具备原子性，所以如何让咱们的代码变得具备 “原子性” ，就是一件很重要的事。

方法也很简单，就是当你在访问一个多线程间共享的资源时，加锁能够实现相似原子操做的效果，一个代码要嘛不执行，执行了的话就要执行完毕，才能接受线程的调度。

所以，咱们使用加锁的方法，对例子一进行一些修改，使其具有原子性。

from threading import Thread, Lock


number = 0
lock = Lock()


def target():
    global number
    for _ in range(1000000):
        with lock:
            number += 1

thread_01 = Thread(target=target)
thread_02 = Thread(target=target)
thread_01.start()
thread_02.start()

thread_01.join()
thread_02.join()

print(number)

此时，无论你执行多少遍，输出都是 2000000.

4. 为何 Queue 是线程安全的？

Python 的 threading 模块里的消息通讯机制主要有以下三种：

1. Event
2. Condition
3. Queue

使用最多的是 Queue，而咱们都知道它是线程安全的。当咱们对它进行写入和提取的操做不会被中断而致使错误，这也是咱们在使用队列时，不须要额外加锁的缘由。

他是如何作到的呢？

其根本缘由就是 Queue 实现了锁原语，所以他能像第三节那样实现人工原子操做。

原语指由若干个机器指令构成的完成某种特定功能的一段程序，具备不可分割性；即原语的执行必须是连续的，在执行过程当中不容许被中断。