python进阶（七）：并发和多线程_python多线程并发

一、多线程

• 原文 | 大纲 | 首页

并发是一种同时执行多个任务的方式，而多线程是一种实现并发的技术。在Python中，可以使用多线程来实现并发编程。了解Python的并发和多线程对于编写高效和响应性的程序非常重要。

并发 vs. 并行

在讨论并发和多线程之前，我们先来了解一下并发和并行的概念。虽然它们经常被混用，但它们有着不同的含义：

• 并发（Concurrency）：指多个任务交替执行的能力。这些任务可能在同一时间段内执行，但不一定是同时执行的。
• 并行（Parallelism）：指多个任务同时执行的能力。这些任务真正地同时执行，利用多个处理器或多核心来提高性能。

Python的多线程机制主要实现了并发，而不是真正的并行。这是因为Python的全局解释锁（Global Interpreter Lock，GIL）限制了同一时刻只能有一个线程执行Python字节码。

使用threading模块

Python的threading模块提供了多线程编程的支持。通过创建多个线程，可以并发执行多个任务。以下是一个简单的示例：

import threading

def task():
    print("Executing task")

# 创建线程
thread = threading.Thread(target=task)

# 启动线程
thread.start()

# 等待线程结束
thread.join()

print("Thread finished")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在上述示例中，我们定义了一个名为task的函数作为线程的执行体。然后，我们创建了一个线程对象thread，并指定了要执行的任务。通过调用start()方法启动线程，并使用join()方法等待线程结束。最后，我们在主线程中打印一条消息表示线程已经结束。

注意：

• 使用threading模块可以创建多个线程，并并发执行多个任务。
• start()方法用于启动线程，使其开始执行。
• join()方法用于等待线程结束，以便在主线程中继续执行。

注意事项

在使用Python的多线程时，有几个注意事项需要记住：

• 全局解释锁（GIL）：Python的全局解释锁限制了同一时刻只能有一个线程执行Python字节码。这意味着在CPU密集型任务中，多线程并不能显著提高性能。但对于I/O密集型任务，多线程仍然可以提供一定的性能优势。
• 竞态条件：多线程可能会引发竞态条件（Race Condition）问题。竞态条件发生在多个线程并发访问和修改共享数据时，导致结果无法预测或不一致。为了避免竞态条件，需要使用同步机制（如锁、信号量等）来保护共享数据的访问。
• 死锁：死锁（Deadlock）是一种多线程编程中常见的问题。它发生在多个线程相互等待对方释放资源而无法继续执行的情况下。为了避免死锁，需要合理设计和管理线程的资源请求和释放。

当然，下面是关于Python线程池的详细说明：

二、线程池

线程池是一种管理和复用线程的机制，它可以提高多线程编程的效率和性能。在Python中，可以使用concurrent.futures模块提供的ThreadPoolExecutor来创建和管理线程池。

创建线程池

要创建一个线程池，可以使用concurrent.futures.ThreadPoolExecutor()构造函数。以下是一个简单的示例：

import concurrent.futures

# 创建线程池
with concurrent.futures.ThreadPoolExecutor() as executor:
    # 执行任务...
1
2
3
4
5

在上述示例中，我们使用with语句创建了一个线程池，并将其赋值给executor变量。通过ThreadPoolExecutor()构造函数创建的线程池默认具有适当数量的线程，可以根据需要进行扩展。

提交任务

要在线程池中执行任务，可以使用submit()方法提交任务。submit()方法接受一个可调用对象（如函数）作为参数，并返回一个Future对象，该对象代表任务的未来结果。以下是一个示例：

import concurrent.futures

def task(name):
    print(f"Executing task: {name}")

# 创建线程池
with concurrent.futures.ThreadPoolExecutor() as executor:
    # 提交任务给线程池
    future = executor.submit(task, "Task 1")

    # 获取任务的结果
    result = future.result()
1
2
3
4
5
6
7
8
9
10
11
12

在上述示例中，我们定义了一个名为task的函数，并将其作为任务提交给线程池。submit()方法返回一个Future对象，表示任务的未来结果。通过future.result()方法可以获取任务的结果。

批量提交任务

除了逐个提交任务，还可以使用map()方法批量提交任务。map()方法接受一个可调用对象和一个迭代器作为参数，并返回一个迭代器，该迭代器按顺序生成每个任务的结果。以下是一个示例：

import concurrent.futures

def task(name):
    print(f"Executing task: {name}")
    return f"Result of task: {name}"

# 创建线程池
with concurrent.futures.ThreadPoolExecutor() as executor:
    # 批量提交任务给线程池
    results = executor.map(task, ["Task 1", "Task 2", "Task 3"])

    # 获取任务的结果
    for result in results:
        print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在上述示例中，我们定义了一个名为task的函数，并将其作为任务批量提交给线程池。通过executor.map()方法可以获取一个迭代器，按顺序生成每个任务的结果。通过遍历迭代器可以获取每个任务的结果。

注意：

• 使用线程池可以方便地执行多个任务，并提高多线程编程的效率和性能。
• 使用submit()方法可以逐个提交任务给线程池，并使用result()方法获取任务的结果。
• 使用map()方法可以批量提交任务给线程池，并通过迭代器获取每个任务的结果。

控制并发度

线程池的并发度是指在同一时间内执行的线程数。默认情况下，线程池的并发度与系统的CPU核心数相同。但是可以通过设置ThreadPoolExecutor的max_workers参数来控制并发度。以下是一个示例：

import concurrent.futures

# 设置并发度为2
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
    # 执行任务...
1
2
3
4
5

在上述示例中，我们通过将max_workers参数设置为2，将线程池的并发度限制为2个线程。这意味着在同一时间内最多只能有2个线程同时执行任务。

结束线程池

当不再需要线程池时，应该显式地关闭线程池以释放资源。可以使用shutdown()方法关闭线程池，它会等待所有线程执行完当前任务后再关闭线程池。以下是一个示例：

import concurrent.futures

# 创建线程池
with concurrent.futures.ThreadPoolExecutor() as executor:
    # 执行任务...

# 关闭线程池
executor.shutdown()
1
2
3
4
5
6
7
8

在上述示例中，我们使用with语句创建了一个线程池，并在代码块中执行任务。在with语句结束时，线程池会自动关闭。如果需要手动关闭线程池，可以调用shutdown()方法。

注意事项

在使用Python的线程池时，有几个注意事项需要记住：

• 任务阻塞：如果任务之间存在依赖关系，可能会发生任务阻塞的情况。这可能导致线程池中的线程长时间等待，从而降低效率。为了避免任务阻塞，可以考虑使用异步编程技术，如asyncio模块。
• 异常处理：任务在执行过程中可能会引发异常。为了避免线程池中的线程被异常终止，应该在任务函数内部进行适当的异常处理，并确保返回一个可识别的结果。
• 资源管理：线程池中的线程共享一些资源（如数据库连接、文件句柄等），需要合理管理和释放这些资源，以避免资源泄漏或竞争条件。

结语

本文详细介绍了Python的并发和多线程。并发是一种同时执行多个任务的方式，而多线程是一种实现并发的技术。通过合理地使用多线程，你可以编写高效和响应性的程序。