浅析python多线程中的锁

import threading
counter = 0  # 共享资源
def increment():
    global counter
    for _ in range(1000000):
        with threading.Lock():  # 获取线程锁
            counter += 1
threads = [threading.Thread(target=increment) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(counter)  # 输出 10000000

import threading
counter = 0  # 共享资源
lock = threading.Lock()  # 创建一个共享的锁
def increment():
    global counter
    for _ in range(1000000):
        with lock:  # 获取线程锁
            counter += 1
threads = [threading.Thread(target=increment) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(counter)  # 输出应该是10000000

import threading
# 创建一个RLock对象
lock = threading.RLock()
def recursive_function(level):
    with lock:
        if level > 0:
            print('Entering level', level)
            recursive_function(level - 1)
            print('Exiting level', level)
        else:
            print('Base case')
# 在主线程中运行递归函数
recursive_function(5)

import threading
import time
# 定义一个有限资源池
RESOURCE_POOL_SIZE = 3
semaphore = threading.Semaphore(RESOURCE_POOL_SIZE)
def access_resource(thread_id):
    print(f"Thread {thread_id} is requesting access to the resource pool.")
    with semaphore:
        print(f"Thread {thread_id} has acquired access to the resource pool.")
        time.sleep(1)  # 模拟资源使用
        print(f"Thread {thread_id} has released access to the resource pool.")
# 创建10个线程
threads = [threading.Thread(target=access_resource, args=(i,)) for i in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()

import threading
# 创建一个有界信号量，初始值为2
semaphore = threading.BoundedSemaphore(2)
def access_resource(thread_id):
    print(f"Thread {thread_id} is requesting access to the resource.")
    with semaphore:
        print(f"Thread {thread_id} has acquired access to the resource.")
        # 模拟资源使用
# 创建3个线程
threads = [threading.Thread(target=access_resource, args=(i,)) for i in range(3)]
for t in threads:
    t.start()
for t in threads:
    t.join()
# 尝试释放未获取的信号量，将引发 ValueError
try:
    semaphore.release()
except ValueError as e:
    print("Caught exception:", e)

import threading
import time
# 创建一个条件变量
condition = threading.Condition()
# 创建一个共享资源
resource = []
def producer():
    for i in range(5):
        time.sleep(1)  # 模拟生产过程
        with condition:
            resource.append(i)  # 向资源中添加数据
            condition.notify()  # 唤醒一个等待的线程
def consumer():
    while True:
        with condition:
            while not resource:  # 如果资源为空，则等待
                condition.wait()
            item = resource.pop(0)  # 从资源中获取数据
            print(f"Consumer consumed: {item}")
            if item == 4:  # 如果消费了所有的资源，就退出循环
                break
# 创建一个生产者线程和一个消费者线程
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
producer_thread.start()
consumer_thread.start()
producer_thread.join()
consumer_thread.join()

import threading
import time
# 设定栅栏，允许3个线程进行同步
barrier = threading.Barrier(3)
def worker(thread_id):
    print(f"Thread {thread_id} is starting.")
    time.sleep(thread_id)  # 模拟线程执行过程中的延时
    print(f"Thread {thread_id} is waiting at the barrier.")
    barrier.wait()  # 等待所有线程到达栅栏
    print(f"Thread {thread_id} is released from the barrier.")
# 创建3个线程
threads = [threading.Thread(target=worker, args=(i,)) for i in range(3)]
for t in threads:
    t.start()
for t in threads:
    t.join()