python 并发编程

### Python 并发编程教程与示例详解

#### 使用 `ThreadPoolExecutor` 实现并发任务执行

为了更好地理解如何利用线程池简化多线程程序开发，可以参考一篇详细的博客文章[^1]。该资源不仅介绍了 `ThreadPoolExecutor` 的基本概念及其优势，还提供了基于实际案例的应用说明。

from concurrent.futures import ThreadPoolExecutor, as_completed

def task(n):
    return n * n

with ThreadPoolExecutor(max_workers=4) as executor:
    futures = [executor.submit(task, i) for i in range(5)]
    
for future in as_completed(futures):
    print(future.result())

这段代码展示了通过 `ThreadPoolExecutor` 来管理一组工作线程，并提交多个异步任务给这些线程处理的方法。当所有任务完成时，会打印出它们的结果。

#### 利用 `fork()` 创建子进程并观察其行为特性

另一个重要的方面是在 Unix/Linux 系统上使用 `os.fork()` 函数创建新进程的能力。下面的例子演示了父进程中变量的变化不会影响到子进程中的相同名称变量的情况：

import os
from time import sleep

print("============================")
a = 1
pid = os.fork()
if pid < 0:
    print("Error")
elif pid == 0:
    print("Child process")
    print("a =", a)
    a = 10000
else:
    sleep(1)
    print("Parent process")
    print('a:', a)
    print("all a =", a)

运行此脚本可以看到，在子进程中修改全局变量 `a` 不会影响父进程内的同名变量值；反之亦然。这表明父子进程之间拥有独立的内存空间副本[^2]。

#### 借助 `multiprocessing` 模块实现跨平台多进程支持

对于那些希望编写能够在不同操作系统平台上正常工作的应用程序来说，Python 提供了内置的支持库——`multiprocessing`。这里给出了一段简单的例子来展示怎样启动几个新的进程去执行特定的任务函数[^3]：

import multiprocessing

def worker(name):
    print(f'Launched process with ID: {multiprocessing.current_process().name}, name: {name}')

if __name__ == '__main__':
    processes = [
        multiprocessing.Process(
            target=worker,
            args=(f'worker-{i}', )
        ) for i in range(5)
    ]
    
    for p in processes:
        p.start()

    for p in processes:
        p.join()

    print('All processes completed.')

上述代码片段中定义了一个名为 `worker` 的辅助函数作为各个子进程的工作负载。接着在一个循环里实例化五个这样的进程对象并将它们加入列表。最后依次调用 `.start()` 方法让每个进程开始运行自己的任务直到结束为止。

#### 处理共享资源的安全访问问题

在设计涉及多个线程或进程共同操作某些数据结构的情况下，必须考虑到同步机制的重要性以防止竞争条件的发生。例如，在银行账户转账场景下可以通过引入锁（Lock）对象来保护临界区的操作过程[^4]：

import threading

class BankAccount:
    def __init__(self):
        self.balance = 0
        self.lock = threading.Lock()

    def deposit(self, amount):
        with self.lock:
            new_balance = self.balance + amount
            sleep(0.1)  # Simulate delay during transaction
            self.balance = new_balance

    def withdraw(self, amount):
        with self.lock:
            if self.balance >= amount:
                new_balance = self.balance - amount
                sleep(0.1)  # Simulate delay during transaction
                self.balance = new_balance
            else:
                raise ValueError("Insufficient funds")

account = BankAccount()
threads = []

for _ in range(10):
    t_deposit = threading.Thread(target=account.deposit, args=(1,))
    threads.append(t_deposit)

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

print(account.balance)

在此基础上构建更复杂的业务逻辑将会更加稳健可靠。