一、多线程：程序世界的 "多面手"

（一）啥是多线程？

咱先打个比方，你去餐厅吃饭，一个服务员同时接待好几桌客人，每桌客人就是一个 "线程"，服务员同时处理多桌事务就是 "多线程"。在程序里，多线程就是让程序同时运行多个任务，各个任务之间相互独立又能协同工作。

（二）多线程的超能力

（三）啥时候用多线程？

多线程特别适合IO 密集型任务，比如网络请求、文件读写、数据库操作等。这些任务大部分时间都在等待 IO 操作完成，多线程可以让 CPU 在等待的时候去处理其他任务。而对于 CPU 密集型任务，由于 Python 的 GIL（全局解释器锁）限制，多线程可能发挥不了太大作用，这时候可以考虑多进程。

二、Python 多线程初体验：threading 模块来帮忙

Python 自带的threading模块让多线程操作变得简单易懂，咱们来看看怎么用它创建多线程。

（一）创建线程的两种姿势

1. 继承 Thread 类

import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            print(f"线程{self.name}正在运行，第{i+1}次")

if __name__ == "__main__":
    thread = MyThread()
    thread.start()
    thread.join()
    print("主线程结束")

这里我们创建了一个继承自threading.Thread的类，重写了run方法，里面就是线程要执行的任务。start()方法启动线程，join()方法让主线程等待子线程结束。

2. 创建 Thread 对象并传入目标函数

import threading
import time

def task(name, times):
    for i in range(times):
        time.sleep(1)
        print(f"线程{name}正在运行，第{i+1}次")

if __name__ == "__main__":
    thread = threading.Thread(target=task, args=("线程1", 3))
    thread.start()
    thread.join()
    print("主线程结束")

这种方式更简单直接，把要执行的函数作为目标传入Thread对象，args参数传递函数的参数。

（二）线程的常用方法

三、多线程的 "坑"：GIL 和线程同步

（一）GIL：Python 多线程的 "紧箍咒"

Python 的 GIL 是一个全局解释器锁，同一时间只有一个线程能执行 Python 字节码。这就导致在 CPU 密集型任务中，多线程并不能真正利用多核 CPU，反而可能因为线程切换带来额外开销。不过在 IO 密集型任务中，由于线程大部分时间都在等待 IO，GIL 的影响就没那么大了。

咱们来做个小实验，看看 GIL 在 CPU 密集型和 IO 密集型任务中的表现。

CPU 密集型任务（计算斐波那契数列）

import threading
import time

def fib(n):
    if n <= 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)

def cpu_task():
    start = time.time()
    fib(35)
    end = time.time()
    print(f"CPU任务耗时：{end - start:.4f}秒")

if __name__ == "__main__":
    start = time.time()
    thread1 = threading.Thread(target=cpu_task)
    thread2 = threading.Thread(target=cpu_task)
    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()
    print(f"两个CPU任务多线程总耗时：{time.time() - start:.4f}秒")

    start = time.time()
    cpu_task()
    cpu_task()
    print(f"两个CPU任务单线程总耗时：{time.time() - start:.4f}秒")

运行结果可能会发现，多线程的耗时并不比单线程少，甚至可能更长，这就是 GIL 的影响。

IO 密集型任务（模拟文件读取）

import threading
import time

def io_task():
    start = time.time()
    time.sleep(2)  # 模拟IO等待
    end = time.time()
    print(f"IO任务耗时：{end - start:.4f}秒")

if __name__ == "__main__":
    start = time.time()
    thread1 = threading.Thread(target=io_task)
    thread2 = threading.Thread(target=io_task)
    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()
    print(f"两个IO任务多线程总耗时：{time.time() - start:.4f}秒")

    start = time.time()
    io_task()
    io_task()
    print(f"两个IO任务单线程总耗时：{time.time() - start:.4f}秒")

这次会看到，多线程的总耗时接近单线程耗时的一半，说明在 IO 密集型任务中，多线程还是很有用的。

（二）线程同步：别让线程 "打架"

当多个线程共享同一资源时，比如全局变量、文件等，如果同时对其进行修改，就可能导致数据不一致。这时候就需要线程同步，常用的工具是锁（Lock）。

import threading

counter = 0
lock = threading.Lock()

def add_task():
    global counter
    for _ in range(1000000):
        # 加锁
        lock.acquire()
        counter += 1
        # 释放锁
        lock.release()

if __name__ == "__main__":
    threads = []
    for i in range(5):
        thread = threading.Thread(target=add_task)
        threads.append(thread)
        thread.start()

    for thread in threads:
        thread.join()

    print(f"最终计数器值：{counter}")

如果不加锁，最终的计数器值可能会小于 5000000，因为多个线程同时修改counter时会出现竞争条件。加上锁之后，就能保证每次只有一个线程修改counter，确保数据的一致性。

四、多线程的正确打开方式

• 适用场景：优先用于 IO 密集型任务，如网络请求、文件读写等；CPU 密集型任务可考虑多进程或异步编程。
• GIL 限制：了解 GIL 对多线程的影响，在 CPU 密集型任务中不要对多线程抱有太高期望。
• 线程同步：涉及共享资源时，一定要使用锁等机制保证线程安全。
• 简单易用：threading模块足够满足大多数多线程需求，入门简单，功能强大。

#如何快速入门Python# #Python#