python如何同时开启两个进程

Python同时开启两个进程，可以使用multiprocessing模块、subprocess模块、os模块。 Multiprocessing模块提供了进程间通信和进程同步的功能，适合处理并行计算；subprocess模块可以用来执行外部命令和脚本，并等待其完成，适合调用外部程序；os模块提供了操作系统接口，可以用来创建子进程，适合简单的进程创建。下面将详细介绍如何使用multiprocessing模块来同时开启两个进程。

一、使用multiprocessing模块

引入multiprocessing模块

Multiprocessing模块是Python标准库的一部分，提供了创建进程、进程间通信和进程同步的功能。它允许你在Python中创建和管理多个进程，从而充分利用多核处理器的能力。

import multiprocessing

创建并启动进程

在multiprocessing模块中，可以通过创建Process对象来创建新的进程。每个Process对象代表一个独立的进程，可以运行一个指定的目标函数。

def worker_1():
    print("Worker 1 is running")
def worker_2():
    print("Worker 2 is running")
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()

在这个示例中，worker_1和worker_2是两个独立的函数，它们将在不同的进程中运行。我们创建了两个Process对象，并将目标函数传递给它们。然后，我们使用start方法启动进程，并使用join方法等待进程完成。

共享数据

在多进程编程中，共享数据是一个常见的需求。multiprocessing模块提供了多种方式来实现进程间的数据共享，包括使用共享内存、队列和管道。

使用共享内存

共享内存允许多个进程访问同一个内存区域，从而实现数据共享。multiprocessing模块提供了Value和Array对象来实现共享内存。

from multiprocessing import Process, Value, Array
def increment_value(shared_value):
    for _ in range(100):
        shared_value.value += 1
if __name__ == "__main__":
    shared_value = Value('i', 0)
    process_1 = Process(target=increment_value, args=(shared_value,))
    process_2 = Process(target=increment_value, args=(shared_value,))
    process_1.start()
    process_2.start()
    process_1.join()
    process_2.join()
    print("Shared Value:", shared_value.value)

在这个示例中，我们创建了一个共享的整数值shared_value，并在两个进程中对其进行递增操作。最后，我们打印出共享值的结果。

使用队列

队列是一种线程安全的数据结构，可以用于在进程之间传递消息。multiprocessing模块提供了Queue类来实现进程间的消息传递。

from multiprocessing import Process, Queue
def worker(queue):
    queue.put("Hello from worker")
if __name__ == "__main__":
    queue = Queue()
    process_1 = Process(target=worker, args=(queue,))
    process_2 = Process(target=worker, args=(queue,))
    process_1.start()
    process_2.start()
    process_1.join()
    process_2.join()
    while not queue.empty():
        print(queue.get())

在这个示例中，我们创建了一个队列queue，并在两个进程中向队列中添加消息。最后，我们从队列中读取并打印消息。

进程同步

在多进程编程中，进程同步是一个重要的问题。multiprocessing模块提供了多种同步原语，包括锁、信号量、事件和条件变量。

使用锁

锁是一种简单的同步原语，可以用于保护共享资源，防止多个进程同时访问。

from multiprocessing import Process, Lock
def worker(lock, shared_value):
    with lock:
        for _ in range(100):
            shared_value.value += 1
if __name__ == "__main__":
    lock = Lock()
    shared_value = Value('i', 0)
    process_1 = Process(target=worker, args=(lock, shared_value))
    process_2 = Process(target=worker, args=(lock, shared_value))
    process_1.start()
    process_2.start()
    process_1.join()
    process_2.join()
    print("Shared Value:", shared_value.value)

在这个示例中，我们创建了一个锁对象lock，并在两个进程中使用锁来保护共享的整数值shared_value。这样可以确保只有一个进程可以在同一时间访问共享值，从而避免竞争条件。

使用事件

事件是一种高级的同步原语，可以用于在进程之间传递信号。multiprocessing模块提供了Event类来实现进程间的事件同步。

from multiprocessing import Process, Event
def worker(event):
    event.wait()
    print("Worker is running")
if __name__ == "__main__":
    event = Event()
    process_1 = Process(target=worker, args=(event,))
    process_2 = Process(target=worker, args=(event,))
    process_1.start()
    process_2.start()
    event.set()
    process_1.join()
    process_2.join()

在这个示例中，我们创建了一个事件对象event，并在两个进程中等待事件被设置。主进程在启动子进程后，通过调用event.set()来设置事件，从而通知子进程继续执行。

二、使用subprocess模块

引入subprocess模块

Subprocess模块是Python标准库的一部分，提供了执行外部命令和脚本的功能。它允许你在Python中创建和管理子进程，并与子进程进行通信。

import subprocess

创建并启动子进程

在subprocess模块中，可以通过调用subprocess.Popen函数来创建新的子进程。Popen函数返回一个Popen对象，表示正在运行的子进程。

process_1 = subprocess.Popen(["python3", "script1.py"])
process_2 = subprocess.Popen(["python3", "script2.py"])
process_1.wait()
process_2.wait()

在这个示例中，我们通过调用subprocess.Popen函数来启动两个子进程，并执行script1.py和script2.py脚本。然后，我们使用wait方法等待子进程完成。

传递输入和获取输出

Subprocess模块提供了多种方式来与子进程进行通信，包括传递输入和获取输出。可以通过设置stdin、stdout和stderr参数来重定向子进程的标准输入、标准输出和标准错误。

process = subprocess.Popen(["python3", "script.py"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = process.communicate(input="Hello from parent process\n")
print("Output:", stdout.decode())
print("Error:", stderr.decode())

在这个示例中，我们通过设置stdin、stdout和stderr参数来重定向子进程的标准输入、标准输出和标准错误。然后，我们通过调用communicate方法传递输入并获取输出。

三、使用os模块

引入os模块

OS模块是Python标准库的一部分，提供了操作系统接口，包括文件和目录操作、进程管理、环境变量等功能。它允许你在Python中创建和管理子进程。

import os

创建并启动子进程

在os模块中，可以通过调用os.fork函数来创建新的子进程。fork函数返回两次，在父进程中返回子进程的PID，在子进程中返回0。

pid_1 = os.fork()
if pid_1 == 0:
    print("Child process 1 is running")
else:
    pid_2 = os.fork()
    if pid_2 == 0:
        print("Child process 2 is running")
    else:
        os.waitpid(pid_1, 0)
        os.waitpid(pid_2, 0)

在这个示例中，我们通过调用os.fork函数来创建两个子进程。然后，父进程通过调用os.waitpid函数等待子进程完成。

执行外部命令

OS模块还提供了os.exec系列函数来执行外部命令。可以通过调用os.execl、os.execvp等函数来替换当前进程的内容，并执行指定的命令。

pid = os.fork()
if pid == 0:
    os.execlp("python3", "python3", "script.py")
else:
    os.waitpid(pid, 0)

在这个示例中，我们通过调用os.fork函数创建一个子进程，并在子进程中通过调用os.execlp函数来执行script.py脚本。然后，父进程通过调用os.waitpid函数等待子进程完成。

总结：

Python同时开启两个进程有多种方式，包括使用multiprocessing模块、subprocess模块和os模块。multiprocessing模块提供了进程间通信和进程同步的功能，适合处理并行计算；subprocess模块可以用来执行外部命令和脚本，并等待其完成，适合调用外部程序；os模块提供了操作系统接口，可以用来创建子进程，适合简单的进程创建。根据具体需求选择合适的模块，可以实现高效的多进程编程。