Python多线程编程中如何正确使用多线程？

import threading
import time
from queue import Queue

# 1. 基础线程创建
def worker_basic(num):
    print(f"线程 {num} 开始执行")
    time.sleep(1)
    print(f"线程 {num} 执行完成")

# 2. 使用锁确保线程安全
counter = 0
lock = threading.Lock()

def worker_with_lock():
    global counter
    with lock:  # 自动获取和释放锁
        temp = counter
        time.sleep(0.001)  # 模拟耗时操作
        counter = temp + 1

# 3. 使用队列进行线程间通信
def producer(q, items):
    for item in items:
        print(f"生产: {item}")
        q.put(item)
        time.sleep(0.1)

def consumer(q):
    while True:
        item = q.get()
        if item is None:  # 终止信号
            break
        print(f"消费: {item}")
        q.task_done()

# 4. 线程池示例（使用concurrent.futures）
from concurrent.futures import ThreadPoolExecutor

def task(n):
    return n * n

def main():
    print("=== 基础线程示例 ===")
    threads = []
    for i in range(3):
        t = threading.Thread(target=worker_basic, args=(i,))
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()
    
    print("\n=== 线程安全示例 ===")
    threads = []
    for _ in range(100):
        t = threading.Thread(target=worker_with_lock)
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()
    print(f"最终计数器值: {counter}")
    
    print("\n=== 生产者-消费者示例 ===")
    q = Queue()
    producer_thread = threading.Thread(target=producer, args=(q, [1, 2, 3, 4, 5]))
    consumer_thread = threading.Thread(target=consumer, args=(q,))
    
    producer_thread.start()
    consumer_thread.start()
    
    producer_thread.join()
    q.put(None)  # 发送终止信号
    consumer_thread.join()
    
    print("\n=== 线程池示例 ===")
    with ThreadPoolExecutor(max_workers=3) as executor:
        futures = [executor.submit(task, i) for i in range(5)]
        results = [f.result() for f in futures]
        print(f"计算结果: {results}")

if __name__ == "__main__":
    main()

关键要点：

1. 创建线程：直接实例化Thread类或继承它
2. 线程同步：使用Lock/RLock防止竞态条件
3. 线程通信：使用Queue实现生产者-消费者模式
4. 线程管理：用join()等待线程结束，或用ThreadPoolExecutor管理线程池
5. GIL限制：CPU密集型任务考虑多进程（multiprocessing）

注意：Python的GIL使得多线程主要适用于I/O密集型任务，CPU密集型任务建议用多进程。

总结：根据任务类型选择合适的并发方式。