blocks|key|1975607|text|对于您的第一个问题，我建议异步任务处理芹菜将是更好的选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1975608|使用芹菜，您可以让用户撤销这些任务：|1975609|结果=+add.apply_async(args=2，2，countdown=120)
result.revoke()|blockquote|1975610|通过撤销，芹菜工作不会执行任务。|1975611|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|N|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|O|8|@]|9|@]|A|$]]]|J|$]]

For your first question, I would suggest for asynchronous task processing Celery would be better choice.

Using Celery you can enable users to revoke the tasks :

<blockquote>
 <blockquote>
 <blockquote>
 result = add.apply_async(args=[2, 2], countdown=120)
 
 result.revoke()
 </blockquote>
 </blockquote>
</blockquote>

By revoking, the celery work wont execute the task

blocks|key|824404|text|调用p.terminate()会向进程发送SIGTERM信号。默认情况下，Python解释器会在这些信号上退出，但在某些情况下它不会：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|824405|该进程正在覆盖SIGTERM信号的默认行为。这可能是Django框架本身设置的(我不知道它是内部的)。|unordered-list-item|824406|进程正在等待C/C%2B%2B调用返回，无法对SIGTERM信号作出反应。|824407|p.join()阻塞调用方，直到子进程未结束为止。必须始终调用它，以便清理过期的子进程。您之所以失去并行性，是因为您启动了新进程并等待它完成。|824408|如果要在单独的进程上生成任务并安全地终止它，可以使用鹅卵石库：|824409|from+pebble+import+process

@process.concurrent
def+library_function(+...+):
++++return

task+=+library_function(+...+)
task.cancel()|code-block|syntax|javascript|824410|更简单。|824411|from+pebble+import+process

task+=+process.concurrent(target=library_function,+args=(+...+))
task.cancel()|824412|编辑：您想要做的事情是不同的，您现在尝试的方式有点危险。|BOLD|824413|在子进程(从multiprocessing.Process而不是subprocess)中运行一个进程池并不是最优的。此外，终止包含池的进程将导致所有工作进程的泄漏。|824414|来自平行文件，它是在幕后使用的进程池的实现。|824415|用“Ctrl”中断多进程作业|blockquote|824416|要实现这一点，您可以向子进程发送一个SIGINT信号，并查看它是否实际工作。|824417|import+multiprocessing,+signal,+os

p+=+multiprocessing.Process(target=library_function,+args=())
p.start()

#+stop+the+job++++
os.kill(p.pid,+signal.SIGINT)
p.join()|824418|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.python.org/pypi/Pebble|1|https://pythonhosted.org/joblib/parallel.html#parallel-reference-documentation^0|2|D|0|0|0|0|8|0|Q|3|0|0|0|0|0|0|2|0|6|N|W|A|0|2|4|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1O|8|@]|D|@]|E|$]]|$1|I|3|J|5|H|7|1P|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1T|8|@]|D|@$9|1U|A|1V|1|1W]]|E|$]]|$1|O|3|P|5|Q|7|1X|8|@]|D|@]|E|$R|S]]|$1|T|3|U|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|V|3|W|5|Q|7|1Z|8|@]|D|@]|E|$R|S]]|$1|X|3|Y|5|6|7|20|8|@$9|21|A|22|B|Z]]|D|@]|E|$]]|$1|10|3|11|5|6|7|23|8|@$9|24|A|25|B|C]|$9|26|A|27|B|C]]|D|@]|E|$]]|$1|12|3|13|5|6|7|28|8|@]|D|@$9|29|A|2A|1|2B]]|E|$]]|$1|14|3|15|5|16|7|2C|8|@]|D|@]|E|$]]|$1|17|3|18|5|6|7|2D|8|@]|D|@]|E|$]]|$1|19|3|1A|5|Q|7|2E|8|@]|D|@]|E|$R|S]]|$1|1B|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]]|1C|$1D|$5|1E|1F|1G|E|$1H|1I]]|1J|$5|1E|1F|1G|E|$1H|1K]]]]

Calling <code>p.terminate()</code> sends a SIGTERM signal to the process. By default Python interpreter exits on such signals but there are cases in which it doesn't:

<ul>
<li>The process is overwriting the default behaviour on SIGTERM signals. This might be set by Django framework itself for example (I don't know it's internals). </li>
<li>The process is waiting for a C/C++ call to return and cannot react to SIGTERM signals.</li>
</ul>

<code>p.join()</code> blocks the caller until the child process does not end. It must always be called in order to clean up the expired child process. The reason why you loose the parallelism is due to the fact that you start the new process and wait until it's done.

You can use the <a href="https://pypi.python.org/pypi/Pebble" rel="nofollow">Pebble</a> library if you want to spawn a task on a separate process and terminate it safely:

<pre><code>from pebble import process

@process.concurrent
def library_function( ... ):
 return

task = library_function( ... )
task.cancel()
</code></pre>

More simply.

<pre><code>from pebble import process

task = process.concurrent(target=library_function, args=( ... ))
task.cancel()
</code></pre>

EDIT: what you want to do is different and the way you're trying to do it at the moment is a bit dangerous.

Running a Pool of processes within a sub Process (from <code>multiprocessing.Process</code> and not <code>subprocess</code>) is not very optimal. Furthermore, terminating the process containing the Pool would lead to the leakage of all the worker processes.

From the <a href="https://pythonhosted.org/joblib/parallel.html#parallel-reference-documentation" rel="nofollow">documentation of Parallel</a> which is the implementation of the Pool of processes used under the hood.

<blockquote>
 Interruption of multiprocesses jobs with ‘Ctrl-C’
</blockquote>

To achieve that, you could send a SIGINT signal to the child process and see whether it actually works.

<pre><code>import multiprocessing, signal, os

p = multiprocessing.Process(target=library_function, args=())
p.start()

# stop the job 
os.kill(p.pid, signal.SIGINT)
p.join()
</code></pre>

I use Django to create a browser-based GUI for a multicore scientific computing library, using gunicorn as a webserver (see also <a href="https://stackoverflow.com/q/31733676/5175389">Start multicore background process from Django view</a>). I call library functions as follows:

<pre><code>p = multiprocessing.Process(target=library_function, args=())
p.start()
print("test")
</code></pre>

The library function handles the multicore logic itself, so the whole point I am also using the multiprocessing module here is to enable the user to terminate the process (via <code>p.terminate()</code>). However, this is currently not working. My assumption is that I also need <code>p.join()</code> to terminate whatever is called by <code>library_function()</code>. The problem is that when I call <code>p.join()</code> after <code>p.start()</code>, the process seems to not run asynchronously anymore, i.e. in the example i.e. "test" is not printed immediately. However, asynchrony is definitely required in my use case.

Does anybody have a hint how to (1) run the process in the background and (2) still enable the user to terminate the process?

UPDATE

Following the comments by noxdafox this is my quick &amp; dirty solution for now:

<pre><code>import psutil, signal, os, multiprocessing

# start process
p = multiprocessing.Process(target=library_function, args=())
p.start()

# stop process
for child in psutil.Process(p.pid).children(recursive=True):
 child.kill() # kill child processes
os.kill(p.pid, signal.SIGKILL) # kill parent process
p.join() # kills parent zombie process
</code></pre>

Terminate asynchronous multiprocessing thread from gunicorn-based web session

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我使用Django为多核科学计算库创建了一个基于浏览器的图形用户界面，使用gunicorn作为see服务器(也请参阅)。我将图书馆的功能称为：p = multiprocessing.Process(target=library_function, args=())p.start()print("test")库函数处理多...

问从基于gunicorn的web会话终止异步多处理线程
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从基于gunicorn的web会话终止异步多处理线程EN