Python 使函数不等待其内部的其他函数

我有如下

flask

服务：

from flask import Flask, request
import json
import time


app = Flask(__name__)

@app.route("/first", methods=["POST"])
def main():
    print("Request received")

    func1()

    return json.dumps({"status": True})


def func1():
    time.sleep(100)
    print("Print function executed")


if __name__ == "__main__":
    app.run("0.0.0.0", 8080)

所以现在当我使用

• 控件转到main方法并打印收到的

  请求

  ，等待执行

  func1

  ，然后返回

  {“status”：True}

---

但是现在我不想等待

func1

完成它的执行，相反，它将发送

{“status”：True}

，而

func1

将继续它的执行。

也许您需要使用子进程？ 您可以尝试以下方法：

import subprocess

subprocess.call(func1())

---

我认为问题在于你规定的POST方法。100秒睡眠时间也太长：）

输出：

Request received1
Print function executed1
Print function executed2
Request received2

---

在接收/执行功能1的请求后，您可以设置/重置全局状态标志/变量（例如，

flag\u func\u 1=True

：已接收请求；

False

：已执行请求）

您可以监视

标志功能1的值，并可以在设置标志后立即返回
{“status”：True}

Ex:在main函数中，您可以执行以下操作：

if(flag_func_1 == True):
  func_1()
  flag_func1 = False

警告，这不是一个可靠的解决方案。您应该查看分布式队列以持久化这些请求（例如：RabbitMQ、Kafka、Redis）

话虽如此。。。您可以使用线程来启动函数

从线程导入线程
@app.route（“/first”，方法=[“GET”]）
def main（）：
打印（“收到请求”）
线程（target=func1，args=（））.start（）
返回json.dumps（{“status”：True}）
如果您需要flask在启动func1（）之前返回响应，您应该检查答案，该答案提供了有关flask必要工作的详细信息

否则，您可以使用线程或多处理：

from threading import Thread
from multiprocessing import Process #and multiprocessing queue if you use this
import queue #for passing messages between main and func1

message_queue = queue.Queue()
@app.route("/first", methods=["GET"])
def main():
    print("Request received")
    func_thread = Thread(target=func1, args=(), daemon=True).start() #daemon if it needs to die with main program, otherwise daemon=False
    #or func_process = Process(...) #in case

    return json.dumps({"status": True})

def func1():
    ...
    print("func 1 ")
    message_queue.put(...) #if you need to pass something
    message_queue.get(...) #to get something like stopping signal
    return


我认为最简单的方法就是使用这个库，多处理

def run_together(*functions):
    processes = []
    for function in functions:
        process = Process(target=function)
        process.start()
        processes.append(process)
    for process in processes:
        process.join()

@app.route("/first", methods=["POST"])
def main():
    print("Request received")

    return run_together(func1, func2)

def func1():
    time.sleep(100)
    print("Print function executed")

def func2():
    return json.dumps({"status": True})

我写了一个粗略的代码，还没有测试过。但我希望这会有帮助，干杯
 为了响应来自flask的请求，您需要完成修饰函数（在您的例子中，这是
main
）

如果您想并行执行某些内容，则需要在另一个线程或进程中执行它。多进程应用程序用于实现多个CPU。（CPU限制）；在您的情况下，您只需要并行执行它，因此最好使用线程

一个简单的技术是使用ThreadPool。从导入
ThreadPoolExecutor
，然后向其提交工作，这将允许函数执行代码继续。试试这个：

from flask import Flask, request
import json
import time
import os
from concurrent.futures import ThreadPoolExecutor


app = Flask(__name__)


# Task manager executor
_threadpool_cpus = int(os.cpu_count() / 2)
EXECUTOR = ThreadPoolExecutor(max_workers=max(_threadpool_cpus, 2))


@app.route("/first", methods=["POST"])
def main():
    print("Request received")
    EXECUTOR.submit(func1)
    return json.dumps({"status": True})


def func1():
    time.sleep(2)
    print("Print function executed")


if __name__ == "__main__":
    app.run("0.0.0.0", 8080)

这将在另一个线程中运行
func1
，允许flask在
func1
完成之前无需阻塞地响应用户。
听起来像是一种先开火后忘记的方法。所以，如果您对
asyncio
感兴趣，这个问题可能会有所帮助：尝试使用芹菜芹菜，您可以将您的函数发送到队列并继续执行下一行代码。我的要求是我不需要；'我不想等待
func1
完成它的执行。上面的代码片段只是一个示例。实际上，
func1
可能需要几个小时才能执行。我不确定子流程在这里有什么帮助
from flask import Flask, request
import json
import time
import os
from concurrent.futures import ThreadPoolExecutor


app = Flask(__name__)


# Task manager executor
_threadpool_cpus = int(os.cpu_count() / 2)
EXECUTOR = ThreadPoolExecutor(max_workers=max(_threadpool_cpus, 2))


@app.route("/first", methods=["POST"])
def main():
    print("Request received")
    EXECUTOR.submit(func1)
    return json.dumps({"status": True})


def func1():
    time.sleep(2)
    print("Print function executed")


if __name__ == "__main__":
    app.run("0.0.0.0", 8080)