Python 如何同时运行两个分支

开头段落: Python可以通过多线程、多进程、异步编程等方式来实现同时运行两个分支、最常用的方法是使用threading模块和multiprocessing模块、异步编程可以使用asyncio模块。其中，threading模块用于多线程编程，适合I/O密集型任务；multiprocessing模块用于多进程编程，适合CPU密集型任务。asyncio模块则是异步编程的一种实现，适合处理大量并发的I/O操作。接下来，本文将详细介绍这些方法，并给出具体的代码示例。

一、THREADING 模块

threading模块是Python标准库中用于实现多线程编程的模块。线程是最小的执行单元，可以并发执行。在多线程编程中，多个线程共享全局变量和资源，这使得线程间通信变得容易，但也带来了线程安全的问题。

1.1 创建线程

要创建一个线程，可以使用threading.Thread类。下面是一个简单的示例，展示了如何创建和启动两个线程：

import threading
import time
def task1():
    for i in range(5):
        print("Task 1 - Iteration", i)
        time.sleep(1)
def task2():
    for i in range(5):
        print("Task 2 - Iteration", i)
        time.sleep(1)
创建线程对象
thread1 = threading.Thread(target=task1)
thread2 = threading.Thread(target=task2)
启动线程
thread1.start()
thread2.start()
等待线程完成
thread1.join()
thread2.join()
print("Both threads have finished their tasks.")

在这个示例中，task1和task2函数分别代表两个不同的任务。我们创建了两个线程thread1和thread2，并分别将这两个任务分配给它们。通过调用start()方法启动线程，并使用join()方法等待线程执行完毕。

1.2 线程锁

由于多个线程共享全局变量和资源，因此需要使用线程锁来避免资源竞争。Python中的threading模块提供了Lock类来实现线程锁。

import threading
创建锁对象
lock = threading.Lock()
共享资源
shared_counter = 0
def increment_counter():
    global shared_counter
    with lock:  # 获取锁
        for _ in range(100000):
            shared_counter += 1
创建线程对象
threads = []
for _ in range(2):
    thread = threading.Thread(target=increment_counter)
    threads.append(thread)
    thread.start()
等待线程完成
for thread in threads:
    thread.join()
print("Final counter value:", shared_counter)

在这个示例中，我们使用lock对象来确保只有一个线程可以访问和修改shared_counter变量，从而避免了资源竞争问题。

二、MULTIPROCESSING 模块

multiprocessing模块是Python标准库中用于实现多进程编程的模块。进程是独立运行的程序实例，每个进程都有自己的内存空间和资源。多进程编程适用于CPU密集型任务，因为每个进程都能利用多核CPU的优势。

2.1 创建进程

要创建一个进程，可以使用multiprocessing.Process类。下面是一个简单的示例，展示了如何创建和启动两个进程：

import multiprocessing
import time
def task1():
    for i in range(5):
        print("Task 1 - Iteration", i)
        time.sleep(1)
def task2():
    for i in range(5):
        print("Task 2 - Iteration", i)
        time.sleep(1)
创建进程对象
process1 = multiprocessing.Process(target=task1)
process2 = multiprocessing.Process(target=task2)
启动进程
process1.start()
process2.start()
等待进程完成
process1.join()
process2.join()
print("Both processes have finished their tasks.")

在这个示例中，task1和task2函数分别代表两个不同的任务。我们创建了两个进程process1和process2，并分别将这两个任务分配给它们。通过调用start()方法启动进程，并使用join()方法等待进程执行完毕。

2.2 进程间通信

由于每个进程都有自己的内存空间，因此需要使用进程间通信（IPC）机制来共享数据。Python中的multiprocessing模块提供了多种IPC机制，例如Queue、Pipe等。

import multiprocessing
def producer(queue):
    for i in range(5):
        queue.put(i)
        print("Produced", i)
def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print("Consumed", item)
创建队列对象
queue = multiprocessing.Queue()
创建进程对象
producer_process = multiprocessing.Process(target=producer, args=(queue,))
consumer_process = multiprocessing.Process(target=consumer, args=(queue,))
启动进程
producer_process.start()
consumer_process.start()
等待生产者完成
producer_process.join()
发送终止信号
queue.put(None)
等待消费者完成
consumer_process.join()
print("Both processes have finished their tasks.")

在这个示例中，我们使用Queue对象在生产者和消费者进程之间传递数据。生产者进程将数据放入队列中，消费者进程从队列中获取数据并处理。

三、ASYNCIO 模块

asyncio模块是Python标准库中用于实现异步编程的模块。异步编程是一种并发编程模型，适用于处理大量并发的I/O操作，例如网络请求、文件读写等。

3.1 创建异步任务

要创建一个异步任务，可以使用asyncio.create_task函数。下面是一个简单的示例，展示了如何创建和运行两个异步任务：

import asyncio
async def task1():
    for i in range(5):
        print("Task 1 - Iteration", i)
        await asyncio.sleep(1)
async def task2():
    for i in range(5):
        print("Task 2 - Iteration", i)
        await asyncio.sleep(1)
async def main():
    # 创建异步任务
    task1_coro = asyncio.create_task(task1())
    task2_coro = asyncio.create_task(task2())
    # 等待任务完成
    await task1_coro
    await task2_coro
运行主函数
asyncio.run(main())
print("Both tasks have finished.")

在这个示例中，task1和task2函数分别代表两个不同的异步任务。我们使用asyncio.create_task函数创建异步任务，并使用await关键字等待任务完成。

3.2 异步上下文管理器

在异步编程中，资源的管理也需要使用异步上下文管理器。Python中的asyncio模块提供了async with语法来实现异步上下文管理。

import asyncio
class AsyncResource:
    async def __aenter__(self):
        print("Entering context")
        return self
    async def __aexit__(self, exc_type, exc, tb):
        print("Exiting context")
    async def do_something(self):
        print("Doing something")
        await asyncio.sleep(1)
async def main():
    async with AsyncResource() as resource:
        await resource.do_something()
运行主函数
asyncio.run(main())