Python多线程适用于I/O密集型任务，通过threading模块创建线程，利用Lock和queue实现同步与通信，但受GIL限制，不适用于CPU密集型场景。

Python多线程主要用于处理I/O密集型任务，比如网络请求、文件读写等，能有效提升程序并发效率。由于GIL（全局解释器锁）的存在，Python的多线程在CPU密集型任务中并不能真正实现并行计算，但在I/O等待期间可以切换线程，提高整体响应速度。

使用threading模块创建线程

Python标准库中的threading模块是实现多线程最常用的方式。可以通过继承Thread类或直接实例化Thread来启动线程。

import threading
import time
def worker(name):
print(f"线程 {name} 开始运行")
time.sleep(2)
print(f"线程 {name} 结束")
创建并启动线程
t1 = threading.Thread(target=worker, args=("A",))
t2 = threading.Thread(target=worker, args=("B",))
t1.start()
t2.start()
t1.join()  # 等待线程结束
t2.join()

示例2：继承Thread类

class MyThread(threading.Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name
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
counter = 0
lock = threading.Lock()
def increment():
global counter
for _ in range(100000):
with lock:  # 自动加锁和释放
counter += 1
threads = []
for i in range(5):
t = threading.Thread(target=increment)
threads.append(t)
t.start()
for t in threads:
t.join()
print("最终计数器:", counter)  # 正确输出 500000

除了Lock，还可以使用RLock（可重入锁）、Semaphore（信号量）、Event（事件通信）等工具进行更复杂的同步控制。
使用queue实现线程间安全通信
Python的queue模块提供了线程安全的队列结构，适合生产者-消费者模型。
生产者-消费者示例
import queue
import threading
import time
q = queue.Queue(maxsize=5)
def producer():
for i in range(10):
q.put(f"任务-{i}")
print(f"生产: 任务-{i}")
time.sleep(0.5)
def consumer():
while True:
item = q.get()
if item is None:
break
print(f"消费: {item}")
time.sleep(1)
q.task_done()
t1 = threading.Thread(target=producer)
t2 = threading.Thread(target=consumer)
t1.start()
t2.start()
t1.join()
q.put(None)  # 停止消费者
t2.join()

注意事项与最佳实践
虽然多线程能提升I/O效率，但使用时需注意以下几点：

GIL限制了同一时刻只有一个线程执行Python字节码，CPU密集型任务建议使用multiprocessing模块
避免频繁创建大量线程，可考虑使用线程池（concurrent.futures.ThreadPoolExecutor）
共享变量必须加锁保护，否则会出现不可预知的错误
注意死锁问题，确保锁能被正确释放，推荐使用with语句管理锁
主线程退出不会自动终止子线程，若希望子线程随主程序结束，可设置为守护线程（daemon=True）

基本上就这些。合理使用Python多线程，配合锁和队列机制，可以在I/O场景中显著提升性能，但要避开GIL陷阱，理解其适用边界。不复杂但容易忽略细节。