简明 Python 教程(第14章 Python的多线程)

Python多线程是指在Python程序中可以同时运行多个线程，每个线程可以执行不同的任务。Python提供了两个标准库来支持多线程：threading和_thread。通常，推荐使用threading模块，因为它提供了更高级别的API，更易于使用。

Python多线程的基本概念：

1. 线程（Thread）：线程是程序执行的最小单元，是操作系统能够进行运算调度的最小单位。Python的线程是直接映射到操作系统的原生线程上的。

2. 全局解释器锁（Global Interpreter Lock GIL）：Python的线程受到全局解释器锁（GIL）的限制，这意味着在任何时刻，只有一个线程可以执行Python字节码。但是，I/O操作和某些其他任务可以释放GIL，从而允许其他线程运行。

3. 线程安全：当多个线程访问共享资源时，如果不当操作可能会导致数据的不一致性。因此，需要采取同步措施来保证线程安全。

使用threading模块的基本步骤：

1. 定义线程任务：创建一个函数，该函数将作为线程的执行体。

2. 创建线程对象：使用threading.Thread构造函数创建线程对象，将目标函数传递给构造函数。

3. 启动线程：调用线程对象的start()方法启动线程。

4. 等待线程结束：可以使用join()方法等待线程结束。

示例：

以下是一个简单的Python多线程示例，其中创建了两个线程，每个线程简单地打印一个字符串多次：

import threading
import time

# 定义线程要执行的代码
def print_numbers():
    for i in range(1, 6):
        time.sleep(1)
        print(f"Thread {threading.current_thread().name} prints {i}")

# 创建线程
thread1 = threading.Thread(target=print_numbers, name='Thread-1')
thread2 = threading.Thread(target=print_numbers, name='Thread-2')

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

# 等待线程执行结束
thread1.join()
thread2.join()

print("主程序结束")

输出示例：

Thread Thread-1 prints 1
Thread Thread-2 prints 1
Thread Thread-1 prints 2
Thread Thread-2 prints 2
Thread Thread-1 prints 3
Thread Thread-2 prints 3
Thread Thread-1 prints 4
Thread Thread-2 prints 4
Thread Thread-1 prints 5
Thread Thread-2 prints 5
主程序结束

注意事项：

• 线程同步：当多个线程需要访问共享资源时，需要使用锁（Lock）或其他同步机制来避免竞态条件。

• 线程池：在实际应用中，通常会使用线程池来管理线程，以避免创建过多的线程资源。

• I/O密集型任务：由于GIL的存在，Python多线程更适合I/O密集型任务，而对于CPU密集型任务，可能需要考虑使用多进程。

• 多进程：对于CPU密集型任务，可以使用multiprocessing模块来实现进程并行，每个进程有自己的Python解释器和内存空间，因此不受GIL的限制。

• 线程优先级：Python线程的优先级是相同的，它们由操作系统的调度器公平调度。

通过合理地使用多线程，可以提高程序的响应性和执行效率，尤其是在I/O操作等待时可以执行其他任务。然而，线程的使用需要仔细考虑同步和资源管理问题，以避免潜在的并发问题。

线程池的应用:

Python线程池是一种执行器（Executor）模式，用于在一个后台线程中执行任务，这有助于程序的并发执行。线程池的主要目的是减少在创建和销毁线程时所产生的性能开销。通过重用已经创建的线程来执行新的任务，线程池提高了程序的效率。

线程池的核心概念包括：

1. 工作线程（Worker Threads）：线程池中的线程，用于执行任务。
2. 任务队列：一个阻塞队列，用于存放待执行的任务。
3. 线程池管理器：负责管理线程的创建、销毁和任务的分发。

Python标准库中的concurrent.futures模块提供了ThreadPoolExecutor类，它是实现线程池的一个非常方便的工具。

ThreadPoolExecutor的主要参数：

• max_workers：线程池中线程的数量，默认为CPU核心数。
• thread_name_prefix：可选参数，用于设置线程的名称前缀。

使用ThreadPoolExecutor的基本步骤：

1. 创建线程池：实例化ThreadPoolExecutor。
2. 提交任务：使用executor.submit()提交需要执行的函数和参数。
3. 关闭线程池：任务执行完毕后，调用executor.shutdown()来关闭线程池。

示例1：

以下是一个使用ThreadPoolExecutor的简单示例，其中创建了一个线程池并在其中执行多个任务：

import concurrent.futures
import time

# 定义一个任务函数
def task(num):
    print(f"Start task {num}")
    time.sleep(1)  # 模拟耗时操作
    print(f"End task {num}")
    return num * num

# 使用线程池执行任务
def main():
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        # 提交任务到线程池
        futures = [executor.submit(task, num) for num in range(10)]
        
        # 等待所有任务完成
        concurrent.futures.wait(futures)
        
        # 获取任务结果
        for future in futures:
            result = future.result()
            print(f"Task result: {result}")

if __name__ == "__main__":
    main()

在这个示例中，我们创建了一个最大容纳5个工作线程的线程池，并提交了10个任务。任务是简单的函数，它们只是休眠1秒并返回一个计算结果。我们使用concurrent.futures.wait()来等待所有任务完成，然后获取每个任务的结果。

示例2：

import requests
from concurrent.futures import ThreadPoolExecutor
import time

# 定义一个下载网页的函数
def download_page(url):
    try:
        response = requests.get(url, timeout=10)  # 10秒超时
        return len(response.content), url
    except requests.RequestException as e:
        print(f"请求失败: {url}, 错误: {e}")
        return None

# 定义一个处理下载结果的函数
def process_results(future):
    result = future.result()
    if result:
        file_size, url = result
        print(f"{url} - 下载了 {file_size} 字节")

# 要下载的网页列表
urls = [
    'http://www.example.com',
    'http://www.google.com',
    'http://www.python.org',
    # 添加更多URL...
]

# 记录开始时间
start_time = time.time()

# 使用线程池下载网页
with ThreadPoolExecutor(max_workers=5) as executor:
    # 提交所有下载任务
    futures = [executor.submit(download_page, url) for url in urls]
    # 为每个任务指定一个处理结果的函数
    for future in futures:
        executor.submit(process_results, future)

# 记录结束时间，并计算总耗时
end_time = time.time()
print(f"所有任务完成，总耗时: {end_time - start_time} 秒")

在这个示例中：

1. 我们定义了download_page函数，它负责下载单个网页并返回网页的大小和URL。

2. process_results函数用于处理下载结果，打印出每个网页的下载情况。

3. 我们创建了一个包含多个URL的列表，并使用ThreadPoolExecutor来创建一个最大容纳5个工作线程的线程池。

4. 使用executor.submit()提交所有下载任务，并使用concurrent.futures.wait()等待所有任务完成。

5. 我们使用executor.submit()再次提交每个future对象到process_results函数，以便异步地处理结果。

6. 在所有任务完成后，我们计算并打印出总耗时。

请注意，多线程环境下进行网络请求时，可能会受到全局解释器锁（GIL）的影响，这意味着如果有大量的CPU密集型操作，可能不会看到显著的性能提升。对于I/O密集型任务，如网络请求，多线程可以提高效率，因为线程可以在等待I/O操作时被操作系统调度去执行其他任务。

 

线程池优势

1. 控制并发数：Python的线程池可以控制系统中运行的线程数量，避免了因为创建过多线程而导致系统资源耗尽。
2. 提高性能：通过复用已经创建的线程，可以避免频繁地创建和销毁线程所带来的性能开销。
3. 简化代码：使用线程池，我们只需要将任务提交给线程池，无需手动管理每个线程的生命周期。
4. 异步处理：Python的线程池提供了异步处理任务的能力。当我们提交任务给线程池后，线程池会在后台进行处理，不会阻塞主程序的执行。
5. 调度方便：线程池还提供了一些调度功能，如定时执行、周期执行等。
6. 任务队列：线程池内部维护了一个任务队列，如果线程池中的所有线程都在忙，新来的任务会被放入队列中等待执行，这样可以保证所有提交给线程池的任务都会被执行，不会丢失。

线程同步 

线程同步是多线程编程中的一个重要概念，用于控制对共享资源的访问，以防止多个线程同时修改数据，从而引发竞态条件和数据不一致的问题。Python提供了多种同步原语，如锁（Lock）、事件（Event）、条件（Condition）和信号量（Semaphore）等，来帮助程序员实现线程间的同步。

以下是一个使用threading.Lock实现线程同步的示例。在这个例子中，多个线程尝试同时更新一个共享的计数器，但为了保证计数的准确性，我们使用锁来确保每次只有一个线程能更新计数器

import threading

# 创建一个锁对象
lock = threading.Lock()

# 共享资源：计数器
counter = 0

# 定义线程要执行的任务
def increment_counter(thread_id):
    global counter
    for _ in range(1000):
        # 使用锁来确保线程安全
        lock.acquire()
        try:
            # 线程安全地更新计数器
            counter += 1
            print(f"Thread {thread_id}: Counter is now {counter}")
        finally:
            # 确保释放锁，即使发生异常
            lock.release()

# 创建线程列表
threads = []

# 创建并启动10个线程
for i in range(10):
    thread = threading.Thread(target=increment_counter, args=(i,))
    threads.append(thread)
    thread.start()

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

print(f"Final counter value: {counter}")

 

在这个示例中：

1. 我们定义了一个全局变量counter作为共享资源，并初始化了一个threading.Lock对象用于同步。

2. 在increment_counter函数中，每个线程将执行1000次对计数器的增加操作。我们使用lock.acquire()来获取锁，确保在更新计数器时不会有其他线程干扰。使用try...finally结构确保即使在更新计数器的过程中发生异常，锁也能被正确释放。

3. 我们创建了10个线程，并将它们存储在threads列表中。每个线程启动后，将并发地执行increment_counter函数。

4. 使用thread.join()等待所有线程完成。这确保了主线程在所有子线程完成之前不会退出。

5. 最后，我们打印出最终的计数器值。

请注意，虽然在这个例子中我们使用了锁来保证计数器更新的线程安全，但在实际应用中，过度使用锁可能会导致性能瓶颈，因为锁会限制线程的并行度。因此，设计多线程程序时需要仔细权衡同步和并行性之间的关系。