Python中如何锁定一个key或者UUID？

我有多个线程会访问一个字典，会对某些 key 的值进行读，处理完了再写，或者读了就不管了

我固然可以直接在字典读写这块的函数加 lock，但是感觉锁太重了

有没有办法能够让多个线程仅仅在同时访问，同一个 key 的时候再锁呢？

zlyuanteng 1楼

上策是修改你的程序架构，使得你不需要锁 key。

中策是预先创建 N 个锁（最好素数个），然后根据你的 key 算个哈希数值，模 N，锁对应的那个锁。

wuwangju 2楼

在Python中，没有内置的“锁定”某个特定键或UUID的机制。这通常指的是在并发环境下，确保对某个特定标识符（如字典的key或一个UUID字符串）关联的资源进行互斥访问。你需要使用线程锁或分布式锁来实现。

核心方法是：为每个需要独立锁定的key，动态地创建和管理一个专用的锁对象。

下面是一个使用threading模块为字典key实现细粒度锁定的示例：

import threading
from collections import defaultdict
import uuid

class KeyLock:
    """一个为不同key提供独立锁的简单管理器"""
    def __init__(self):
        # 使用defaultdict动态创建锁，避免重复创建
        self._locks = defaultdict(threading.Lock)
        # 用于保护_locks字典本身操作的锁，防止在创建新锁时出现竞态条件
        self._meta_lock = threading.Lock()

    def get_lock(self, key):
        """获取指定key对应的锁对象"""
        # 注意：这里使用_meta_lock来保证对_locks字典的线程安全访问
        with self._meta_lock:
            return self._locks[key]

    def __call__(self, key):
        """使其可被用作装饰器或上下文管理器"""
        return self.get_lock(key)

# 使用示例
key_lock = KeyLock()
shared_dict = {}

def safe_write(key, value):
    # 获取这个特定key的锁
    lock = key_lock(key)
    with lock:
        # 临界区：对共享资源的操作
        shared_dict[key] = value
        print(f"Thread {threading.current_thread().name} wrote {value} to key {key}")

# 模拟多线程操作
def worker(key_vals):
    for key, val in key_vals:
        safe_write(key, val)

if __name__ == "__main__":
    # 生成一些测试用的UUID作为key
    keys = [str(uuid.uuid4()) for _ in range(3)]
    # 创建两个线程，它们会操作重叠的key
    import concurrent.futures

    thread_data = [
        [(keys[0], 'A1'), (keys[1], 'B1'), (keys[0], 'A2')], # 线程1会重复操作keys[0]
        [(keys[1], 'B2'), (keys[0], 'A3'), (keys[2], 'C1')]  # 线程2也会操作keys[0]和keys[1]
    ]

    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
        executor.map(worker, thread_data)

    print("\nFinal shared_dict:", shared_dict)

关键点解释：