Python 共享变量加锁、释放详解

在多线程环境下，共享变量的访问会带来数据不一致的问题，因此需要使用锁机制来保证线程安全。Python 提供了 threading 模块来实现多线程和锁机制。

一、什么是锁？

锁是一种同步机制，用来保护共享资源不被并发访问。在多线程环境下，如果没有锁机制，多个线程同时访问同一个共享变量，就会导致数据不一致的问题。比如，一个线程正在修改共享变量，另一个线程正在读取该变量，这时读到的数据可能是不一致的。

二、Python 中的锁机制

Python 提供了 threading 模块来实现多线程和锁机制。其中 Lock 是最常用的锁。

1. 使用 Lock 加锁与释放

我们可以使用 Lock 来保护每一个对共享变量的访问，避免多个线程同时对同一个变量进行写操作，从而导致数据不一致。

import threading

def func(lock: threading.Lock, shared_variable: list):
    # 加锁
    lock.acquire()

    # 访问共享变量
    shared_variable.append(1)

    # 释放锁
    lock.release()

# 在多线程环境下，共享变量 shared_variable 可能会被多个线程同时访问，此时需要加锁保护
if __name__ == '__main__':
    lock = threading.Lock()
    shared_variable = []
    threads = []
    for i in range(10):
        t = threading.Thread(target=func, args=(lock, shared_variable))
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

    print('shared_variable:', shared_variable)

2. with 语句加锁与释放

我们也可以使用 with 语句来简化加锁和释放过程。

import threading

def func(lock: threading.Lock, shared_variable: list):
    # with 语句会自动加锁和释放
    with lock:
        shared_variable.append(1)

# 在多线程环境下，共享变量 shared_variable 可能会被多个线程同时访问，此时需要加锁保护
if __name__ == '__main__':
    lock = threading.Lock()
    shared_variable = []
    threads = []
    for i in range(10):
        t = threading.Thread(target=func, args=(lock, shared_variable))
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

    print('shared_variable:', shared_variable)

三、示例

示例一：使用 Lock 保护多个共享变量

下面这个示例中，有两个共享变量，我们需要使用 Lock 来保护这两个变量，避免多个线程同时访问它们导致数据不一致。

import threading

def func(lock: threading.Lock, shared_variable_1: list, shared_variable_2: list):
    # with 语句会自动加锁和释放
    with lock:
        shared_variable_1.append(1)
        shared_variable_2.append(2)

if __name__ == '__main__':
    lock = threading.Lock()
    shared_variable_1 = []
    shared_variable_2 = []
    threads = []
    for i in range(10):
        t = threading.Thread(target=func, args=(lock, shared_variable_1, shared_variable_2))
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

    print('shared_variable_1:', shared_variable_1)
    print('shared_variable_2:', shared_variable_2)

示例二：死锁

下面这个示例中，当一个线程等待另一个线程释放锁的时候，如果另一个线程一直持有锁不释放，就会导致死锁。

import threading
import time

def func(lock1: threading.Lock, lock2: threading.Lock):
    with lock1:
        print('Thread-1 locked lock1')
        time.sleep(1)
        with lock2:
            print('Thread-1 locked lock2')

    with lock2:
        print('Thread-1 locked lock2-2')

if __name__ == '__main__':
    lock1 = threading.Lock()
    lock2 = threading.Lock()
    threads = []
    t1 = threading.Thread(target=func, args=(lock1, lock2))
    t2 = threading.Thread(target=func, args=(lock2, lock1))
    threads.append(t1)
    threads.append(t2)
    t1.start()
    t2.start()

    for t in threads:
        t.join()

四、总结

在多线程环境下，为了保证共享变量的正确性，需要使用锁机制来保证线程安全。Python 中提供了 threading 模块来实现多线程和锁机制，其中 Lock 是最常用的锁。在使用 Lock 的过程中，需要注意加锁和释放锁的顺序，否则可能会导致死锁的问题。通过加锁可以保证共享变量的正确性，从而避免数据不一致的问题。