多线程如何实现资源共享

在多线程编程中，资源共享是指多个线程能够访问和操作共享的数据或资源。为了实现资源共享，需要使用同步机制来确保数据的一致性和线程安全。以下是一些常见的同步机制和方法：

1. 互斥锁（Mutex）

互斥锁是一种最基本的同步机制，用于保护共享资源，确保同一时间只有一个线程可以访问该资源。

import threading

lock = threading.Lock()
shared_resource = 0

def increment():
    global shared_resource
    with lock:
        shared_resource += 1

threads = [threading.Thread(target=increment) for _ in range(10)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()

print(shared_resource)  # 输出 10

2. 条件变量（Condition）

条件变量允许线程在某个条件满足时等待，并在条件改变时通知其他线程。

import threading

condition = threading.Condition()
shared_resource = []

def producer():
    for i in range(5):
        with condition:
            shared_resource.append(i)
            condition.notify()  # 通知等待的消费者线程

def consumer():
    while True:
        with condition:
            while not shared_resource:
                condition.wait()  # 等待生产者线程的通知
            item = shared_resource.pop(0)
            print(f"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()

3. 信号量（Semaphore）

信号量是一种计数器，用于控制对共享资源的访问。它可以用来限制同时访问某个资源的线程数量。

import threading

semaphore = threading.Semaphore(2)  # 允许最多2个线程同时访问
shared_resource = []

def access_resource(thread_id):
    with semaphore:
        print(f"Thread {thread_id} is accessing the resource")
        shared_resource.append(thread_id)
        # 模拟资源访问时间
        threading.Event().wait(1)
        shared_resource.remove(thread_id)
        print(f"Thread {thread_id} has finished accessing the resource")

threads = [threading.Thread(target=access_resource, args=(i,)) for i in range(5)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()

4. 读写锁（ReadWriteLock）

读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。

import threading

rw_lock = threading.RLock()
shared_resource = 0

def reader(thread_id):
    with rw_lock:
        print(f"Reader {thread_id} is reading: {shared_resource}")

def writer(thread_id):
    global shared_resource
    with rw_lock:
        shared_resource += 1
        print(f"Writer {thread_id} is writing: {shared_resource}")

read_threads = [threading.Thread(target=reader, args=(i,)) for i in range(5)]
write_threads = [threading.Thread(target=writer, args=(i,)) for i in range(2)]

for thread in read_threads:
    thread.start()
for thread in write_threads:
    thread.start()

for thread in read_threads:
    thread.join()
for thread in write_threads:
    thread.join()

5. 原子操作

原子操作是指不可中断的操作，可以确保在多线程环境下操作的原子性。Python 的 threading 模块没有直接提供原子操作，但可以使用 multiprocessing.Value 或 multiprocessing.Array 来实现。

from multiprocessing import Process, Value
import ctypes

def increment(counter):
    with counter.get_lock():
        counter.value += 1

if __name__ == "__main__":
    counter = Value(ctypes.c_int, 0)
    processes = [Process(target=increment, args=(counter,)) for _ in range(10)]

    for process in processes:
        process.start()
    for process in processes:
        process.join()

    print(counter.value)  # 输出 10

通过这些同步机制，可以有效地实现多线程之间的资源共享，确保数据的一致性和线程安全。