Python 中线程间通信的方式有哪些？-JavaScript中文网-JavaScript教程资源分享门户

本题详细解读

共享变量

共享变量是最简单的线程间通信方式。多个线程可以访问和修改同一个全局变量或类成员变量。然而，由于Python的全局解释器锁（GIL），多线程在CPU密集型任务中并不能真正并行执行，但在I/O密集型任务中仍然有用。

// www.javascriptcn.com code example
import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

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

for thread in threads:
    thread.join()

print(counter)  # 输出应为1000000

队列（Queue）

队列是线程安全的，适用于生产者-消费者模型。生产者线程将数据放入队列，消费者线程从队列中取出数据。

// www.javascriptcn.com code example
import threading
import queue
import time

def producer(q):
    for i in range(5):
        print(f"Producing {i}")
        q.put(i)
        time.sleep(1)

def consumer(q):
    while True:
        item = q.get()
        if item is None:
            break
        print(f"Consuming {item}")
        q.task_done()

q = queue.Queue()
threads = []

p = threading.Thread(target=producer, args=(q,))
c = threading.Thread(target=consumer, args=(q,))

p.start()
c.start()

p.join()
q.put(None)  # 发送结束信号
c.join()

事件（Event）

事件用于线程间的简单信号通信。一个线程可以通过设置事件来通知其他线程某个条件已经满足。

// www.javascriptcn.com code example
import threading
import time

event = threading.Event()

def waiter():
    print("Waiting for the event to be set")
    event.wait()
    print("Event was set, continuing execution")

def setter():
    time.sleep(2)
    print("Setting the event")
    event.set()

threading.Thread(target=waiter).start()
threading.Thread(target=setter).start()

条件变量（Condition）

条件变量用于更复杂的线程同步。它允许线程等待某个条件成立，并在条件成立时通知其他线程。

// www.javascriptcn.com code example
import threading

condition = threading.Condition()
items = []

def consumer():
    with condition:
        while not items:
            condition.wait()
        items.pop()
        print("Consumed an item")

def producer():
    with condition:
        items.append("item")
        condition.notify()
        print("Produced an item")

threading.Thread(target=consumer).start()
threading.Thread(target=producer).start()

信号量（Semaphore）

信号量用于控制对共享资源的访问。信号量可以限制同时访问某个资源的线程数量。

// www.javascriptcn.com code example
import threading
import time

semaphore = threading.Semaphore(2)

def access_resource(thread_id):
    with semaphore:
        print(f"Thread {thread_id} is accessing the resource")
        time.sleep(2)
        print(f"Thread {thread_id} is releasing the resource")

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

for thread in threads:
    thread.join()

管道（Pipe）

管道可以用于线程间的双向通信。虽然multiprocessing模块主要用于进程间通信，但Pipe也可以用于线程间通信。

// www.javascriptcn.com code example
from multiprocessing import Pipe
import threading

def sender(conn):
    conn.send("Hello from sender")
    conn.close()

def receiver(conn):
    msg = conn.recv()
    print(f"Received: {msg}")
    conn.close()

parent_conn, child_conn = Pipe()

threading.Thread(target=sender, args=(child_conn,)).start()
threading.Thread(target=receiver, args=(parent_conn,)).start()

Python 中线程间通信的方式有哪些？

推荐答案