多线程编程中不同线程间如何进行通信

# 创建一个共享变量
shared_variable = 0

# 线程1
def increment_shared_variable():
    global shared_variable
    shared_variable += 1

# 线程2
def decrement_shared_variable():
    global shared_variable
    shared_variable -= 1

# 启动线程
import threading
t1 = threading.Thread(target=increment_shared_variable)
t2 = threading.Thread(target=decrement_shared_variable)
t1.start()
t2.start()

# 等待线程完成
t1.join()
t2.join()

# 打印共享变量的最终值
print(shared_variable)  # 输出：0

import threading

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

# 线程1
def access_shared_resource():
    with lock:
        # 在该代码块内，只有当前线程可以访问共享资源

# 线程2
def access_shared_resource_2():
    with lock:
        # 只有线程1释放锁后，线程2才能访问共享资源

# 启动线程
t1 = threading.Thread(target=access_shared_resource)
t2 = threading.Thread(target=access_shared_resource_2)
t1.start()
t2.start()

# 等待线程完成
t1.join()
t2.join()

import threading

# 创建一个事件
event = threading.Event()

# 线程1
def do_something():
    # 执行一些操作
    event.set()  # 事件发生

# 线程2
def wait_for_event():
    event.wait()  # 等待事件发生

# 启动线程
t1 = threading.Thread(target=do_something)
t2 = threading.Thread(target=wait_for_event)
t1.start()
t2.start()

# 等待线程完成
t1.join()
t2.join()

import threading

# 创建一个信号量
semaphore = threading.Semaphore(3)  # 允许最多 3 个线程同时访问资源

# 线程1
def access_shared_resource():
    with semaphore:
        # 只有当信号量可用时，才能访问共享资源

# 启动多个线程
threads = []
for i in range(10):
    t = threading.Thread(target=access_shared_resource)
    threads.append(t)
    t.start()

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

import queue

# 创建一个消息队列
queue = queue.Queue()

# 线程1
def producer():
    queue.put("Hello, world!")

# 线程2
def consumer():
    message = queue.get()  # 等待并获取消息

# 启动线程
t1 = threading.Thread(target=producer)
t2 = threading.Thread(target=consumer)
t1.start()
t2.start()

# 等待线程完成
t1.join()
t2.join()