Question

我正在尝试同时运行两个python文件（A.py和B.py）。我尝试以两种不同的方式运行它们，并使用两个单独的命令来运行它们，效果很好。

问题是，我希望有一个脚本文件可以并行运行它们。我尝试使用以下代码进行多处理：

HttpSession httpSession = httpServletRequest.getSession(false);
DefaultSavedRequest savedRequest = (DefaultSavedRequest) 
           httpSession.getAttribute("SPRING_SECURITY_SAVED_REQUEST");
Map<String, String[]> parametersMap =  savedRequest.getParameterMap();

结果是它两次在A和B上运行，我希望它们对它们每个仅运行一次。

问题的原因是什么，如何解决？还是有其他解决方案可以并行运行两个python文件？

谢谢您的帮助。

对于我的导入信息，我有三个文件：A.py，B.py和run.py。

在A.py中，我有：

if __name__ == '__main__':
    jobs=[]
    jobs.append(Process(target=A.start))
    jobs.append(Process(target=B.start))

    for job in jobs:
        job.start()

    for job in jobs:
        job.join()

在B.py中，我有：

from scapy.all import *
from scapy.layers.http import HTTPRequest 
from scapy.layers.http import HTTPResponse
from colorama import init, Fore
import docker
import time
import redis

在run.py中，我有：

import json
import docker
import socket
import time
import psutil
import socket
import redis
import prometheus_client
from prometheus_client import Gauge,Counter
from prometheus_client.core import CollectorRegistry
from flask import Response, Flask

====更新问题原因====

经过数小时的代码使用，我想我找到了原因，但我不明白为什么。

原因在我的A.py文件中，我有一个代码

from multiprocessing import Process
import A
import B

如果我删除了调试模式，则代码运行良好。仅在打开调试模式时，才会出现此问题。

有人知道为什么会这样吗？

Answer 1

首先，我将确保在脚本中，您具有要在可调用函数中运行的脚本。然后确保像from fileA import A这样开始导入函数。

from multiprocessing import Process
import time
# from fileA import A
# from fileB import B


def A():
    print("Running A")
    time.sleep(2)
    print("Ending A")


def B():
    print("Running B")
    time.sleep(3)
    print("Ending B")

if __name__ == '__main__':
    jobs=[]
    jobs.append(Process(target=A))
    jobs.append(Process(target=B))

    for job in jobs:
        job.start()

    for job in jobs:
        job.join()

输出：

Running A
Ending A
Running B
Ending B
[Finished in 3.2s]

Answer 2

我认为您正在寻找的是multiprocessing.Pool，尤其是Pool.apply_async。这将允许您异步启动将并行执行无关任务的单独进程。您可以像这样使用它：

A.py：

def square(x):
    print('x squared is: ' + str(x**2))

B.py：

def cube(x):
    print('x cubed is: ' + str(x**3))

然后：

import multiprocessing as mp
import A
import B

p = mp.Pool(2)

a = p.apply_async(A.square, args=(5,))
b = p.apply_async(B.cube, args=(7,))

p.close()

更新

好吧，有了新的信息，这是有一个非常简单但可能不是显而易见的原因发生的，它与您使用多处理无关（尽管这很可能会给您带来麻烦，您打算在真正的网络服务器上运行此应用，而不是在Flask内置的服务器上运行。

在debug处于打开状态的use_reloader模式下运行Flask调试服务器时，它将启动2个进程。父进程监视您的代码，并在检测到更改时通知子进程重新加载。这就是Flask服务器能够立即应用您所做的任何代码更改而无需执行任何操作的原因。您遇到的问题是您的代码同时在父级和子级中运行。

有2种修复方法。

请勿使用debug=True。
使用debug=True，但也可以通过添加use_reloader=False来禁用重新加载器。

选项（2）可能是更有吸引力的解决方案，因为您仍然可以访问调试控制台，但是您还将失去自动重装功能，因此您需要在应用更改之前手动重新启动服务器。为此，请将您的app.run行更改为此：

app.run(host="0.0.0.0", port=15600, debug=True, use_reloader=False)

Python多进程多次运行

2 个答案:

更新