「Python系列」Python 多线程

一、Python多线程

在Python中，多线程编程意味着同时使用多个线程来执行代码。Python的标准库提供了threading模块来支持多线程编程。线程是程序执行流的最小单元，它是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈），但它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

下面是一个简单的Python多线程示例：

import threading

# 定义一个线程类，继承自threading.Thread
class MyThread(threading.Thread):
    def __init__(self, thread_id, name):
        threading.Thread.__init__(self)
        self.thread_id = thread_id
        self.name = name

    # 定义线程运行时要执行的代码
    def run(self):
        print(f"线程 {self.name} ({self.thread_id}) 开始运行")
        # 这里可以放置线程需要执行的代码
        print(f"线程 {self.name} ({self.thread_id}) 结束运行")

# 创建线程对象
thread1 = MyThread(1, "Thread-1")
thread2 = MyThread(2, "Thread-2")

# 启动线程
thread1.start()
thread2.start()

# 等待线程完成
thread1.join()
thread2.join()

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

在这个例子中，我们定义了一个名为MyThread的线程类，它继承自threading.Thread。我们重写了run方法，该方法定义了线程启动后要执行的代码。然后，我们创建了两个线程对象，并通过调用它们的start方法来启动这些线程。join方法用于等待线程完成。

需要注意的是，由于Python的全局解释器锁（GIL）的存在，Python的多线程在大多数情况下并不能实现真正的并行计算。GIL确保了同一时间只有一个线程可以执行Python代码，这限制了多线程在CPU密集型任务上的性能提升。然而，多线程在进行I/O密集型操作时仍然非常有用，因为它们可以在一个线程等待I/O操作完成时让另一个线程继续执行。

对于需要并行执行的计算密集型任务，可以使用multiprocessing模块来创建多进程，或者使用concurrent.futures模块来更灵活地管理多线程或多进程。

此外，还有一些第三方库如concurrent.futures提供了更高级的API来管理并行执行的任务，它支持多线程、多进程和异步执行。使用concurrent.futures可以让你的代码更加简洁和易于维护。

二、线程模块

在Python中，threading模块提供了创建和管理线程的基础设施。这个模块支持原生的线程，并允许程序员创建和管理线程，以及设置线程间的同步。

下面是一些threading模块中常用的类和函数：

类

1. Thread: 这是表示线程的基础类。你可以通过继承这个类并重写run()方法来定义线程的行为。

class MyThread(threading.Thread):
    def run(self):
        # 线程执行的代码

1. Lock: 锁对象用于管理对共享资源的访问。当多个线程需要访问共享资源时，可以使用锁来确保资源在任何时候只被一个线程访问。

lock = threading.Lock()

# 在需要保护的代码块前加锁
lock.acquire()
try:
    # 访问共享资源的代码
finally:
    # 无论发生何种情况，都要释放锁
    lock.release()

1. RLock: 可重入锁对象，允许同一个线程多次获得同一个锁。
2. Condition: 条件变量，它允许线程等待某个条件成立，或者通知其他线程某个条件已经成立。
3. Semaphore: 信号量，它是一个计数器，用于控制对共享资源的访问数量。
4. Event: 事件对象，允许线程之间发送简单的信号。
5. Barrier: 屏障对象，用于同步一组线程，直到所有线程都到达某个点。

函数

1. threading.current_thread(): 返回当前的线程对象。
2. threading.enumerate(): 返回一个包含所有当前活动线程的列表。
3. threading.active_count(): 返回当前活动的线程数量。
4. threading.setprofile(func): 设置线程的profile函数。
5. threading.settrace(func): 设置线程的trace函数。

示例

下面是一个使用threading模块中Thread和Lock的简单示例：

import threading

# 共享资源
counter = 0
lock = threading.Lock()

# 线程函数
def increment_counter():
    global counter
    for _ in range(100000):  # 模拟大量操作
        # 获取锁
        lock.acquire()
        try:
            counter += 1
        finally:
            # 释放锁
            lock.release()

# 创建线程
threads = []
for _ in range(10):  # 创建10个线程
    t = threading.Thread(target=increment_counter)
    threads.append(t)
    t.start()

# 等待所有线程完成
for t in threads:
    t.join()

print("Final counter value:", counter)

在这个示例中，我们创建了一个共享资源counter和一个锁lock。我们定义了一个函数increment_counter，它将在一个线程中执行，并且每次都会增加counter的值。为了确保线程安全，我们在修改counter时使用lock来同步线程。

threading模块还有其他功能和更高级的用法，但是上面列举的是一些最基础和最常用的元素。在编写多线程应用时，你应当注意线程间的数据共享和同步问题，以避免竞态条件和其他并发问题。

三、threading.Thread 类

threading.Thread 类在 Python 中提供了丰富的方法和属性来管理线程的生命周期和行为。以下是一些关键的方法和属性：

方法

1. __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
   构造函数，用于初始化线程对象。
   • group: 线程组，未使用，默认为 None。
   • target: 要由线程运行的可调用对象。
   • name: 线程的名字，默认为 'Thread-N'，其中 n 是一个小整数。
   • args: 传递给 target 函数的参数元组。
   • kwargs: 传递给 target 函数的关键字参数字典。
2. start(self):
   启动线程的活动。它必须在线程对象被创建后、且尚未启动前调用。
3. run(self):
   线程启动后要执行的代码，通常通过重写此方法来定义线程行为。
4. join(self, timeout=None):
   阻塞调用线程，直到线程对象表示的线程终止。可选的 timeout 参数可以是一个浮点数，表示等待的最长时间（以秒为单位）。
5. setDaemon(self, daemonic):
   设置线程的守护状态。当 daemonic 为 True 时，线程将成为守护线程。守护线程在主线程结束时自动终止，不论其任务是否完成。
6. isDaemon(self):
   返回线程的守护状态。
7. setName(self, name):
   设置线程的名字。
8. getName(self):
   返回线程的名字。

属性

1. name:
   线程的名字，可以通过 setName() 方法设置。
2. ident:
   线程的“线程标识符”，一个非零整数。这是线程的唯一标识符，当线程尚未启动时，该属性为 None。
3. daemon:
   线程的守护状态，可以通过 setDaemon() 方法设置。

使用 threading.Thread 类时，通常的做法是重写 run 方法来定义线程的行为，并通过 start 方法启动线程。然后，可以使用 join 方法等待线程完成，或者使用 isAlive 方法来检查线程是否仍在运行。

请注意，由于全局解释器锁（GIL）的存在，Python 的多线程在 CPU 密集型任务上的表现可能不如多进程。然而，多线程在进行 I/O 密集型操作时仍然非常有用，因为 GIL 只在执行 Python 字节码时才会锁定线程，而在执行 I/O 操作（如文件读写、网络通信等）时，GIL 会被释放，允许多个线程同时执行。

四、Python 多线程优缺点

Python 的多线程编程具有一些优点和缺点，并且可以根据任务类型进行分类。

优点

1. 提高程序的执行效率：多线程可以将任务分配给不同的线程并行执行，从而提高程序的执行速度。
2. 提高系统的资源利用率：多线程可以充分利用多核处理器的性能，提高系统资源的利用效率。
3. 提高用户体验：多线程可以将耗时的操作放在后台执行，保证程序的响应能力，提高用户体验。
4. 简化编程模型：多线程可以将复杂的任务拆分成多个子任务，每个子任务由一个线程执行，从而简化编程模型，提高代码的可读性和可维护性。
5. 共享资源：多线程可以共享内存资源，方便数据的共享和通信。

缺点

1. 全局解释器锁（GIL）：Python 的全局解释器锁限制了同一时间内只有一个线程可以执行 Python 代码，这导致多线程在 CPU 密集型任务上的性能提升有限。
2. 复杂性增加：多线程编程涉及到线程间同步和通信的问题，可能增加程序的复杂性。
3. 资源消耗：创建和管理线程需要一定的系统资源，如果线程数量过多，可能会导致资源不足。

分类

根据任务类型，多线程可以分为两种：

1. I/O 密集型任务：这类任务涉及大量的 I/O 操作，如文件读写、网络通信等。由于 I/O 操作会阻塞线程的执行，因此多线程可以提高程序的执行效率，减少等待时间。
2. 计算密集型任务：这类任务需要大量的计算，如数学计算、图像处理等。由于 Python 的全局解释器锁限制，多线程在 CPU 密集型任务上的性能提升有限。在这种情况下，可以考虑使用多进程或协程来提高性能。

需要注意的是，虽然多线程在某些情况下可以提高程序的性能，但并不是所有情况下都适用。在选择是否使用多线程时，需要根据具体任务类型、系统资源和性能需求进行权衡。

五、相关链接

1. Python下载安装中心
2. Python官网
3. Python软件下载
4. 「Python系列」Python简介及案例
5. 「Python系列」Python基础语法/数据类型
6. 「Python系列」Python解释器
7. 「Python系列」Python运算符
8. 「Python系列」Python数据结构
9. 「Python系列」Python元组
10. 「Python系列」Python集合
11. 「Python系列」Python列表