多线程优势：

• 提高响应性：主线程保持响应，后台线程处理耗时任务
• 资源共享：线程共享内存，通信更高效
• 经济高效：创建线程比创建进程开销小
• 提高效率：特别适合I/O密集型任务

Python线程实现方式：

• _thread：Python的低级线程模块（不推荐）
• threading：高级线程接口（推荐）
• concurrent.futures：线程池实现

方式一：函数式创建线程

import threading
import time

def task(name, delay):
    print(f"线程 {name} 开始运行")
    time.sleep(delay)
    print(f"线程 {name} 完成，耗时 {delay} 秒")

# 创建线程
t1 = threading.Thread(target=task, args=("Thread-1", 2))
t2 = threading.Thread(target=task, args=("Thread-2", 3))

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

print("所有线程执行完毕")

方式二：继承Thread类

import threading

class MyThread(threading.Thread):
    def __init__(self, name, delay):
        super().__init__()
        self.name = name
        self.delay = delay
        
    def run(self):
        print(f"线程 {self.name} 开始运行")
        time.sleep(self.delay)
        print(f"线程 {self.name} 完成，耗时 {self.delay} 秒")

# 创建线程实例
t1 = MyThread("Thread-A", 2)
t2 = MyThread("Thread-B", 3)

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

print("所有线程执行完毕")

4.1 ThreadPoolExecutor基本使用

from concurrent.futures import ThreadPoolExecutor
import time

def task(n):
    print(f"处理任务 {n}")
    time.sleep(1)
    return n * n

# 创建包含4个线程的线程池
with ThreadPoolExecutor(max_workers=4) as executor:
    # 提交任务
    futures = [executor.submit(task, i) for i in range(10)]
    
    # 获取结果
    for future in futures:
        print(f"结果: {future.result()}")

4.2 使用map简化操作

with ThreadPoolExecutor(max_workers=4) as executor:
    # 使用map提交多个任务
    results = executor.map(task, range(10))
    
    # 直接获取结果
    for result in results:
        print(f"结果: {result}")

4.3 异步回调处理

def callback(future):
    print(f"回调收到结果: {future.result()}")

with ThreadPoolExecutor() as executor:
    future = executor.submit(task, 5)
    future.add_done_callback(callback)
    print("主线程继续执行其他操作...")

# 输出:
# 主线程继续执行其他操作...
# 处理任务 5
# 回调收到结果: 25

绕过GIL的策略

• 使用多进程：multiprocessing模块绕过GIL限制
• 使用异步IO：asyncio处理高并发I/O操作
• 使用C扩展：在C扩展中释放GIL
• 使用其他解释器：如Jython或IronPython

性能优化建议

• 使用线程池而不是频繁创建新线程
• 减少线程间通信和数据共享
• 使用适当的同步原语
• 避免在持有锁时执行I/O操作
• 设置合理的线程数量（通常为CPU核心数的2-5倍）
• 优先使用queue模块进行线程间通信

调试与错误处理

• 使用threading.current_thread().name标识线程
• 使用logging模块代替print（线程安全）
• 处理线程中的异常（避免静默失败）
• 使用threading.enumerate()查看所有活动线程
• 避免死锁（按固定顺序获取锁）