python如何同时启两个进程

使用 Python 同时启动两个进程，可以使用多进程模块（如 multiprocessing 模块）。以下是几个方法：使用 multiprocessing 模块、使用 subprocess 模块、使用 os.fork() 函数。其中，使用 multiprocessing 模块是最常见和推荐的方法。下面我们将详细介绍如何使用 multiprocessing 模块来实现同时启动两个进程。

一、使用 multiprocessing 模块

Python 的 multiprocessing 模块允许你创建多个进程，每个进程运行独立的任务。以下是一个示例，演示了如何使用 multiprocessing 模块同时启动两个进程：

import multiprocessing
import time
def worker_1():
    print("Worker 1 starting")
    time.sleep(2)
    print("Worker 1 finished")
def worker_2():
    print("Worker 2 starting")
    time.sleep(3)
    print("Worker 2 finished")
if __name__ == "__main__":
    process_1 = multiprocessing.Process(target=worker_1)
    process_2 = multiprocessing.Process(target=worker_2)
    process_1.start()
    process_2.start()
    process_1.join()
    process_2.join()
    print("Both processes finished")

在这个示例中，我们定义了两个函数 worker_1 和 worker_2，每个函数模拟一个任务。我们创建了两个进程 process_1 和 process_2，并分别启动它们。最后，我们使用 join() 方法等待两个进程都完成执行。

这种方法的优点在于代码结构清晰、易于维护，同时可以充分利用多核 CPU 提高程序的执行效率。

二、使用 subprocess 模块

subprocess 模块可以用来创建子进程并与其进行通信。下面是一个使用 subprocess 模块同时启动两个进程的示例：

import subprocess
def run_command(command):
    process = subprocess.Popen(command, shell=True)
    process.wait()
if __name__ == "__main__":
    command_1 = "python3 -c 'import time; time.sleep(2); print(\"Command 1 finished\")'"
    command_2 = "python3 -c 'import time; time.sleep(3); print(\"Command 2 finished\")'"
    process_1 = subprocess.Popen(command_1, shell=True)
    process_2 = subprocess.Popen(command_2, shell=True)
    process_1.wait()
    process_2.wait()
    print("Both commands finished")

在这个示例中，我们使用 subprocess.Popen 来启动两个子进程，并分别执行两个命令。我们使用 wait() 方法等待两个子进程都完成执行。

这种方法的优点在于可以直接运行 shell 命令，非常灵活，但需要注意安全性，避免命令注入攻击。

三、使用 os.fork() 函数

os.fork() 函数可以用来创建一个子进程。以下是一个使用 os.fork() 函数同时启动两个进程的示例：

import os
import time
def worker_1():
    print("Worker 1 starting")
    time.sleep(2)
    print("Worker 1 finished")
def worker_2():
    print("Worker 2 starting")
    time.sleep(3)
    print("Worker 2 finished")
if __name__ == "__main__":
    pid = os.fork()
    if pid == 0:
        worker_1()
    else:
        pid = os.fork()
        if pid == 0:
            worker_2()
        else:
            os.wait()
            os.wait()
            print("Both processes finished")

在这个示例中，我们使用 os.fork() 函数创建两个子进程，并分别执行 worker_1 和 worker_2 函数。我们使用 os.wait() 等待两个子进程都完成执行。

这种方法的优点在于直接调用系统的 fork 函数，性能较高，但代码复杂度较高，不太适合初学者。

四、使用 concurrent.futures 模块

concurrent.futures 模块提供了一个高级接口来管理并发任务。以下是一个使用 concurrent.futures 模块同时启动两个进程的示例：

import concurrent.futures
import time
def worker_1():
    print("Worker 1 starting")
    time.sleep(2)
    print("Worker 1 finished")
    return "Worker 1 result"
def worker_2():
    print("Worker 2 starting")
    time.sleep(3)
    print("Worker 2 finished")
    return "Worker 2 result"
if __name__ == "__main__":
    with concurrent.futures.ProcessPoolExecutor() as executor:
        future_1 = executor.submit(worker_1)
        future_2 = executor.submit(worker_2)
        result_1 = future_1.result()
        result_2 = future_2.result()
    print("Both processes finished")
    print("Result 1:", result_1)
    print("Result 2:", result_2)

在这个示例中，我们使用 concurrent.futures.ProcessPoolExecutor 来管理并发任务。我们使用 submit 方法提交任务，并使用 result 方法获取任务的结果。

这种方法的优点在于接口简洁、易于使用，同时提供了线程池和进程池两种并发模型。

五、使用 threading 模块

尽管 threading 模块主要用于线程而非进程，但在某些情况下也可以用来实现并发。以下是一个使用 threading 模块同时启动两个线程的示例：

import threading
import time
def worker_1():
    print("Worker 1 starting")
    time.sleep(2)
    print("Worker 1 finished")
def worker_2():
    print("Worker 2 starting")
    time.sleep(3)
    print("Worker 2 finished")
if __name__ == "__main__":
    thread_1 = threading.Thread(target=worker_1)
    thread_2 = threading.Thread(target=worker_2)
    thread_1.start()
    thread_2.start()
    thread_1.join()
    thread_2.join()
    print("Both threads finished")

在这个示例中，我们使用 threading.Thread 来创建和启动两个线程，并分别执行 worker_1 和 worker_2 函数。我们使用 join() 方法等待两个线程都完成执行。

需要注意的是，Python 的 GIL（全局解释器锁）限制了多线程的并行执行，因此对于 CPU 密集型任务，线程可能无法提供显著的性能提升。

六、使用 asyncio 模块

asyncio 模块可以用来编写异步代码，适用于 I/O 密集型任务。以下是一个使用 asyncio 模块同时启动两个协程的示例：

import asyncio
async def worker_1():
    print("Worker 1 starting")
    await asyncio.sleep(2)
    print("Worker 1 finished")
async def worker_2():
    print("Worker 2 starting")
    await asyncio.sleep(3)
    print("Worker 2 finished")
async def main():
    await asyncio.gather(worker_1(), worker_2())
if __name__ == "__main__":
    asyncio.run(main())