Python多线程适用于I/O密集型任务，通过threading模块创建线程，利用Lock和queue实现同步与通信，但受GIL限制，不适用于CPU密集型场景。
Python多线程主要用于处理I/O密集型任务，比如网络请求、文件读写等，能有效提升程序并发效率。由于GIL（全局解释器锁）的存在，Python的多线程在CPU密集型任务中并不能真正实现并行计算，但在I/O等待期间可以切换线程，提高整体响应速度。
使用threading模块创建线程
Python标准库中的threading模块是实现多线程最常用的方式。可以通过继承Thread类或直接实例化Thread来启动线程。
示例1：直接创建线程
import threading
import time
<p>def worker(name):
print(f"线程 {name} 开始运行")
time.sleep(2)
print(f"线程 {name} 结束")</p><h1>创建并启动线程</h1><p>t1 = threading.Thread(target=worker, args=("A",))
t2 = threading.Thread(target=worker, args=("B",))</p><p>t1.start()
t2.start()</p><p>t1.join() # 等待线程结束
t2.join()
</p>示例2：继承Thread类
立即学习“Python免费学习笔记（深入）”；
class MyThread(threading.Thread):
def __init__(self, name):
super().__init__()
self.name = name
<pre class="brush:php;toolbar:false;">def run(self):
print(f"线程 {self.name} 开始")
time.sleep(2)
print(f"线程 {self.name} 结束")t1 = MyThread("X") t2 = MyThread("Y") t1.start() t2.start() t1.join() t2.join()
线程同步与资源共享
多个线程访问共享数据时容易引发竞争条件，需要使用锁机制保护关键代码段。
使用Lock避免数据冲突
import threading
<p>counter = 0
lock = threading.Lock()</p><p>def increment():
global counter
for _ in range(100000):
with lock: # 自动加锁和释放
counter += 1</p><p>threads = []
for i in range(5):
t = threading.Thread(target=increment)
threads.append(t)
t.start()</p><p>for t in threads:
t.join()</p><p>print("最终计数器:", counter) # 正确输出 500000
</p>除了Lock，还可以使用RLock（可重入锁）、Semaphore（信号量）、Event（事件通信）等工具进行更复杂的同步控制。
使用queue实现线程间安全通信
Python的queue模块提供了线程安全的队列结构，适合生产者-消费者模型。
生产者-消费者示例
import queue
import threading
import time
<p>q = queue.Queue(maxsize=5)</p><p>def producer():
for i in range(10):
q.put(f"任务-{i}")
print(f"生产: 任务-{i}")
time.sleep(0.5)</p><p>def consumer():
while True:
item = q.get()
if item is None:
break
print(f"消费: {item}")
time.sleep(1)
q.task_done()</p><p>t1 = threading.Thread(target=producer)
t2 = threading.Thread(target=consumer)</p><p>t1.start()
t2.start()</p><p>t1.join()
q.put(None) # 停止消费者
t2.join()
</p>注意事项与最佳实践
虽然多线程能提升I/O效率，但使用时需注意以下几点：
- GIL限制了同一时刻只有一个线程执行Python字节码，CPU密集型任务建议使用multiprocessing模块
- 避免频繁创建大量线程，可考虑使用线程池（concurrent.futures.ThreadPoolExecutor）
- 共享变量必须加锁保护，否则会出现不可预知的错误
- 注意死锁问题，确保锁能被正确释放，推荐使用with语句管理锁
- 主线程退出不会自动终止子线程，若希望子线程随主程序结束，可设置为守护线程（daemon=True）
基本上就这些。合理使用Python多线程，配合锁和队列机制，可以在I/O场景中显著提升性能，但要避开GIL陷阱，理解其适用边界。不复杂但容易忽略细节。
