【Python】线程—GIL—asyncio

---

它们的特点和适用场景：

工具	特点	适用场景
Lock	最基本的互斥锁，一次只允许一个线程访问共享资源不可重入，即同一线程再次获取会导致死锁	简单的线程同步需求 需要确保一段代码同一时间只能被一个线程执行
RLock	可重入锁，同一线程可以多次获取锁并释放允许同一线程多次调用 acquire()	复杂的递归线程同步需求某些情况下需要允许同一线程多次获取和释放锁
Semaphore	允许一定数量的线程同时访问共享资源控制并发数量	有限资源的并发控制控制同时运行的线程数量，比如限流
Event	可以通过 set() 和 clear() 设置和清除事件状态 线程可以等待事件的发生	线程间通信和同步一个线程等待某个事件的发生，另一个线程触发事件
Condition	提供了更高级的线程同步机制，结合了锁和事件	复杂的线程协调和通信需求- 允许线程等待某个条件，其他线程在满足条件时通知等待的线程继续执行

3.21 Lock（锁）

• threading.Lock 类提供了最基本的线程同步机制，它可以确保一次只有一个线程可以访问共享资源。
• acquire() 方法用于获取锁，release() 方法用于释放锁。
• 示例：

import threading
import time

# 创建一个锁对象
lock = threading.Lock()


def worker():
    # 获取锁
    lock.acquire()
    try:
        # 执行需要同步的操作
        print("Thread {} is working...".format(threading.Thread.getName(t)))
        # 模拟耗时操作
        time.sleep(1)
    finally:
        # 释放锁
        lock.release()


# 创建多个线程并启动它们
threads = []
for i in range(5):
    t = threading.Thread(target=worker)
    threads.append(t)
    t.start()

# 等待所有线程完成
for t in threads:
    t.join()

print("All threads finished.")

3.22 RLock（递归锁）

• threading.RLock 是一个可重入锁，允许同一线程多次获得锁。
• acquire() 和 release() 方法的使用方式与 Lock 类似，但允许同一线程多次调用 acquire()。
• 示例：

import threading
import time


class Counter:
    def \_\_init\_\_(self):
        self.value = 0
        self.lock = threading.RLock()

    def increment(self):
        with self.lock:
            self.value += 1
            print(f"Incremented to {self.value} by {threading.currentThread().getName()}")
            time.sleep(0.1)  # 模拟一些计算或I/O操作

    def decrement(self):
        with self.lock:
            self.value -= 1
            print(f"Decremented to {self.value} by {threading.currentThread().getName()}")