天道酬勤,学无止境

python multiprocessing.Pool kill *特定* 长时间运行或挂起的进程(python multiprocessing.Pool kill *specific* long running or hung process)

问题

我需要执行许多并行数据库连接和查询的池。 我想使用 multiprocessing.Pool 或 concurrent.futures ProcessPoolExecutor。 蟒蛇 2.7.5

在某些情况下,查询请求花费的时间太长或永远不会完成(挂起/僵尸进程)。 我想从已超时的 multiprocessing.Pool 或 concurrent.futures ProcessPoolExecutor 中终止特定进程。

这是一个如何杀死/重新生成整个进程池的示例,但理想情况下我会尽量减少 CPU 抖动,因为我只想杀死一个特定的长时间运行的进程,该进程在超时秒后没有返回数据。

出于某种原因,在返回并完成所有结果后,下面的代码似乎无法终止/加入进程池。 它可能与超时发生时杀死工作进程有关,但是池会在他们被杀死时创建新的工作人员并且结果如预期。

from multiprocessing import Pool
import time
import numpy as np
from threading import Timer
import thread, time, sys

def f(x):
    time.sleep(x)
    return x

if __name__ == '__main__':
    pool = Pool(processes=4, maxtasksperchild=4)

    results = [(x, pool.apply_async(f, (x,))) for x in np.random.randint(10, size=10).tolist()]

    while results:
        try:
            x, result = results.pop(0)
            start = time.time()
            print result.get(timeout=5), '%d done in %f Seconds!' % (x, time.time()-start)

        except Exception as e:
            print str(e)
            print '%d Timeout Exception! in %f' % (x, time.time()-start)
            for p in pool._pool:
                if p.exitcode is None:
                    p.terminate()

    pool.terminate()
    pool.join()
回答1

我没有完全理解你的问题。 你说你想停止一个特定的进程,但是在你的异常处理阶段,你正在调用所有作业的终止。 不知道你为什么这样做。 另外,我很确定使用来自multiprocessing.Pool内部变量不太安全。 说了这么多,我认为你的问题是为什么这个程序在超时发生时没有完成。 如果这是问题所在,那么以下方法可以解决问题:

from multiprocessing import Pool
import time
import numpy as np
from threading import Timer
import thread, time, sys

def f(x):
    time.sleep(x)
    return x

if __name__ == '__main__':
    pool = Pool(processes=4, maxtasksperchild=4)

    results = [(x, pool.apply_async(f, (x,))) for x in np.random.randint(10, size=10).tolist()]

    result = None
    start = time.time()
    while results:
        try:
            x, result = results.pop(0)
            print result.get(timeout=5), '%d done in %f Seconds!' % (x, time.time()-start)
        except Exception as e:
            print str(e)
            print '%d Timeout Exception! in %f' % (x, time.time()-start)
            for i in reversed(range(len(pool._pool))):
                p = pool._pool[i]
                if p.exitcode is None:
                    p.terminate()
                del pool._pool[i]

    pool.terminate()
    pool.join()

关键是您需要从池中删除项目; 仅仅对它们调用终止是不够的。

回答2

在您的解决方案中,您正在篡改池本身的内部变量。 该池依赖 3 个不同的线程才能正确运行,在没有真正意识到您在做什么的情况下干预它们的内部变量是不安全的。

在标准 Python 池中没有一种干净的方法来停止超时进程,但是有一些替代实现可以公开此类功能。

您可以查看以下库:

卵石

台球

回答3

为了避免访问内部变量,您可以将multiprocessing.current_process().pid从正在执行的任务保存到共享内存中。 然后从主进程迭代multiprocessing.active_children()并杀死目标pid如果存在)。
然而,在工人的这种外部终止之后,他们被重新创建,但池变得不可加入并且还需要在join()之前显式终止

回答4

我也遇到了这个问题。

原始代码和@stacksia 编辑的版本有相同的问题:在这两种情况下,当只有一个进程达到超时时(即当pool._pool上的循环完成时), pool._pool所有当前正在运行的进程。

在我的解决方案下面找到。 它涉及按照.pid建议为每个工作进程创建一个.pid文件。 如果有一种方法可以标记每个工作进程(在下面的代码中, x完成这项工作),它将起作用。 如果有人有更优雅的解决方案(例如将 PID 保存在内存中),请分享。

#!/usr/bin/env python

from multiprocessing import Pool
import time, os
import subprocess

def f(x):
    PID = os.getpid()
    print 'Started:', x, 'PID=', PID

    pidfile = "/tmp/PoolWorker_"+str(x)+".pid"

    if os.path.isfile(pidfile):
        print "%s already exists, exiting" % pidfile
        sys.exit()

    file(pidfile, 'w').write(str(PID))

    # Do the work here
    time.sleep(x*x)

    # Delete the PID file
    os.remove(pidfile)

    return x*x


if __name__ == '__main__':
    pool = Pool(processes=3, maxtasksperchild=4)

    results = [(x, pool.apply_async(f, (x,))) for x in [1,2,3,4,5,6]]

    pool.close()

    while results:
        print results
        try:
            x, result = results.pop(0)
            start = time.time()
            print result.get(timeout=3), '%d done in %f Seconds!' % (x, time.time()-start)

        except Exception as e:
            print str(e)
            print '%d Timeout Exception! in %f' % (x, time.time()-start)

            # We know which process gave us an exception: it is "x", so let's kill it!

            # First, let's get the PID of that process:
            pidfile = '/tmp/PoolWorker_'+str(x)+'.pid'
            PID = None
            if os.path.isfile(pidfile):
                PID = str(open(pidfile).read())
                print x, 'pidfile=',pidfile, 'PID=', PID

            # Now, let's check if there is indeed such process runing:
            for p in pool._pool:
                print p, p.pid
                if str(p.pid)==PID:
                    print 'Found  it still running!', p, p.pid, p.is_alive(), p.exitcode

                    # We can also double-check how long it's been running with system 'ps' command:"
                    tt = str(subprocess.check_output('ps -p "'+str(p.pid)+'" o etimes=', shell=True)).strip()
                    print 'Run time from OS (may be way off the real time..) = ', tt

                    # Now, KILL the m*$@r:
                    p.terminate()
                    pool._pool.remove(p)
                    pool._repopulate_pool()

                    # Let's not forget to remove the pidfile
                    os.remove(pidfile)

                    break

    pool.terminate()
    pool.join()

很多人推荐鹅卵石。 它看起来不错,但仅适用于 Python 3。如果有人有办法为 Python 2.6 导入卵石 - 那就太好了。

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • Python 3中的Concurrent.futures与Multiprocessing(Concurrent.futures vs Multiprocessing in Python 3)
    问题 Python 3.2引入了Concurrent Futures,这似乎是较旧的线程和多处理模块的一些高级组合。 与较旧的多处理模块相比,将此功能用于与CPU绑定的任务有什么优点和缺点? 本文建议他们更容易使用-是这样吗? 回答1 我不会称其为“更高级”的concurrent.futures -它是一个更简单的接口,其工作原理几乎相同,无论您使用多个线程还是多个进程作为基础并行化ization头。 所以,像“简单的界面”的几乎所有情况下,大同小异的取舍都参与:它有一个浅的学习曲线,这在很大程度上只是因为有可用少了这么多需要学习; 但是,由于它提供的选项较少,因此最终可能使您无法使用更丰富的界面而感到沮丧。 就与CPU绑定的任务而言,这还不够具体,以至于说不出什么有意义的事情。 对于CPython下与CPU绑定的任务,您需要多个进程而不是多个线程才能获得加速的机会。 但是,获得多少加速(如果有的话)取决于硬件,操作系统的详细信息,尤其取决于特定任务需要多少进程间通信。 在幕后,所有进程间并行化头都依赖于相同的OS原语-用于获得这些原语的高级API并不是底线速度的主要因素。 编辑:示例 这是您引用的文章中显示的最终代码,但是我添加了使它起作用所需的import语句: from concurrent.futures import ProcessPoolExecutor def
  • Python多处理:子进程崩溃?(Python Multiprocessing: Crash in subprocess?)
    问题 当python脚本打开子进程并且一个进程崩溃时,会发生什么? https://stackoverflow.com/a/18216437/311901 主进程会崩溃吗? 其他子进程会崩溃吗? 是否有传播的信号或其他事件? 回答1 当使用multiprocessing.Pool ,如果池中的一个子进程崩溃了,则将不会收到任何通知,并且将立即开始一个新的进程来代替它: >>> import multiprocessing >>> p = multiprocessing.Pool() >>> p._processes 4 >>> p._pool [<Process(PoolWorker-1, started daemon)>, <Process(PoolWorker-2, started daemon)>, <Process(PoolWorker-3, started daemon)>, <Process(PoolWorker-4, started daemon)>] >>> [proc.pid for proc in p._pool] [30760, 30761, 30762, 30763] 然后在另一个窗口中: dan@dantop:~$ kill 30763 回到泳池: >>> [proc.pid for proc in p._pool] [30760, 30761
  • Python多处理模块:超时连接过程(Python multiprocessing module: join processes with timeout)
    问题 我正在对复杂模拟的参数进行优化。 我使用多处理模块来增强优化算法的性能。 我在http://pymotw.com/2/multiprocessing/basics.html上了解了多处理的基础知识。 复杂的模拟根据优化算法中给定的参数持续不同的时间,大约1到5分钟。 如果参数选择不正确,则模拟可能会持续30分钟或更长时间,结果将无用。 因此,我正在考虑为多处理建立超时,该超时将终止所有持续时间超过定义时间的模拟。 这是问题的抽象版本: import numpy as np import time import multiprocessing def worker(num): time.sleep(np.random.random()*20) def main(): pnum = 10 procs = [] for i in range(pnum): p = multiprocessing.Process(target=worker, args=(i,), name = ('process_' + str(i+1))) procs.append(p) p.start() print 'starting', p.name for p in procs: p.join(5) print 'stopping', p.name if __name__ == "__main__"
  • 操作系统 进程概念
    进程的基本概念程序:一个在时间上严格按先后次序操作实现算法功能的指令序列,程序本身是静态的。进程:描述性定义:计算机中的所有程序(软件),按照某种顺序运行,这种运行的过程称之为进程。另一种定义是:可并发执行的程序在一个数据集合上的执行过程。程序执行有固定的时序 特征:顺序性、封闭性、可再现性顺序性:处理机的操作严格按规定顺序执行封闭性:程序执行时,独占系统资源可再现性:当初始条件相同时,程序多次执行的结果相同程序的并发执行多个程序的并发执行(可能性分析)特征间断性:程序在并发执行时,形成了相互制约关系。相互制约将导致并发程序具有“执行—暂停—执行”这种间断性的活动规律失去封闭性:主要由共享资源引起,系统中的资源供多个程序共享,致使程序的运行失去了封闭性不可再现性:并发程序对资源的共享与竞争,又会导致程序执行环境与运行速度的改变,从而可能产生程序运行结果不唯一问题。再现性问题:若两个程序P1和P2满足下述条件,便能并发执行且有可再现性: R(P1)∩W(P2)∪R(P2)∩W(P1)∪W(P1)∩W(P2) = { } “读集” R ( Pi ) 为程序 Pi 在执行期间所需参考的所有变量的集合。 “写集” W ( Pi )为程序 Pi 在执行期间所需改变的所有变量的集合。 例如:S1: a := x + y S2: b := z + 1 S3: c := a - b S4: d
  • 如何在python Tornado服务器的请求内最好地执行多处理?(How to best perform Multiprocessing within requests with the python Tornado server?)
    问题 我正在使用I / O非阻塞python服务器Tornado。 我有一类GET请求,可能需要花费大量时间才能完成(请考虑5-10秒的范围)。 问题在于,龙卷风会阻止这些请求,因此后续的快速请求将被阻止,直到慢速请求完成。 我看了一下:https://github.com/facebook/tornado/wiki/Threading-and-concurrency,得出的结论是我想要#3(其他进程)和#4(其他线程)的某种组合。 #4本身有问题,当有另一个线程执行“ heavy_lifting”时,我无法可靠地控制回到ioloop。 (我认为这是由于GIL造成的,而且heavy_lifting任务具有很高的CPU负载,并且一直将控制权从主要ioloop移开,但这是一个猜测)。 因此,我一直在为如何解决这些问题提供原型,该方法是在一个单独的进程中通过在这些缓慢的GET请求中执行“繁重的任务”,然后在完成该过程以完成请求时将回调放置回Tornado ioloop中。 这释放了ioloop来处理其他请求。 我创建了一个简单的示例,演示了可能的解决方案,但很好奇能从社区中获得反馈。 我的问题有两个:如何简化当前的方法? 它可能存在哪些陷阱? 该方法 利用Tornado的内置asynchronous装饰器,该装饰器允许请求保持打开状态并让ioloop继续。
  • multiprocessing pool.map 按特定顺序调用函数(multiprocessing pool.map call functions in certain order)
    问题 如何让 multiprocessing.pool.map 按数字顺序分发进程? 更多信息: 我有一个程序可以处理几千个数据文件,并对每个文件进行绘图。 我正在使用multiprocessing.pool.map将每个文件分发到处理器,并且效果很好。 有时这需要很长时间,在程序运行时查看输出图像会很好。 如果地图进程按顺序分发快照,这会容易得多; 相反,对于我刚刚执行的特定运行,分析的前 8 个快照是: 0, 78, 156, 234, 312, 390, 468, 546 。 有没有办法让它按数字顺序更紧密地分布它们? 例子: 这是包含相同关键元素的示例代码,并显示相同的基本结果: import sys from multiprocessing import Pool import time num_proc = 4; num_calls = 20; sleeper = 0.1 def SomeFunc(arg): time.sleep(sleeper) print "%5d" % (arg), sys.stdout.flush() # otherwise doesn't print properly on single line proc_pool = Pool(num_proc) proc_pool.map( SomeFunc, range(num_calls) ) 产量
  • 使用子流程模块会释放python GIL吗?(Does using the subprocess module release the python GIL?)
    问题 当通过Python的subprocess模块调用花费相对较长时间的linux二进制文件时,这会释放GIL吗? 我想并行处理一些从命令行调用二进制程序的代码。 使用线程(通过threading和multiprocessing.pool.ThreadPool )还是使用multiprocessing更好? 我的假设是,如果subprocess发布了GIL,那么选择threading选项会更好。 回答1 当通过Python的subprocess模块调用花费相对较长时间的linux二进制文件时,这会释放GIL吗? 是的,它将在调用过程中释放全局解释器锁定(GIL)。 如您所知,在POSIX平台上, subprocess在fork , execve和waitpid的“原始”组件之上提供了便利的接口。 通过检查CPython 2.7.9源, fork和execve不会释放GIL。 但是,这些调用不会阻塞,因此我们不希望GIL被释放。 waitpid当然会阻止,但是我们看到它的实现确实使用ALLOW_THREADS宏放弃了GIL: static PyObject * posix_waitpid(PyObject *self, PyObject *args) { .... Py_BEGIN_ALLOW_THREADS pid = waitpid(pid, &status, options)
  • Python 多处理池在加入时挂起?(Python multiprocessing pool hangs at join?)
    问题 我正在尝试在多个文件上并行运行一些 python 代码。 构造基本上是: def process_file(filename, foo, bar, baz=biz): # do stuff that may fail and cause exception if __name__ == '__main__': # setup code setting parameters foo, bar, and biz psize = multiprocessing.cpu_count()*2 pool = multiprocessing.Pool(processes=psize) map(lambda x: pool.apply_async(process_file, (x, foo, bar), dict(baz=biz)), sys.argv[1:]) pool.close() pool.join() 我以前使用过 pool.map 来做类似的事情并且效果很好,但我似乎不能在这里使用它,因为 pool.map 不允许(似乎)允许我传入额外的参数(并使用 lambda 到这样做是行不通的,因为 lambda 不能被编组)。 所以现在我试图直接使用 apply_async() 来让事情工作。 我的问题是代码似乎挂起并且永远不会退出。 一些文件因异常而失败,但我不明白为什么会导致连接失败
  • python multiprocessing-进程在大队列的联接上挂起(python multiprocessing - process hangs on join for large queue)
    问题 我正在运行python 2.7.3,发现以下奇怪行为。 考虑以下最小示例: from multiprocessing import Process, Queue def foo(qin, qout): while True: bar = qin.get() if bar is None: break qout.put({'bar': bar}) if __name__ == '__main__': import sys qin = Queue() qout = Queue() worker = Process(target=foo,args=(qin,qout)) worker.start() for i in range(100000): print i sys.stdout.flush() qin.put(i**2) qin.put(None) worker.join() 当我循环超过10,000或更多时,我的脚本会挂在worker.join() 。 当循环仅达到1,000时,它可以正常工作。 有任何想法吗? 回答1 子qout中的qout队列已满。 从foo()中放入的数据不适合内部使用的OS管道的缓冲区,因此子进程将阻止尝试容纳更多数据。 但是父进程没有读取该数据:它也被简单地阻塞,等待子进程完成。 这是一个典型的僵局。 回答2 队列大小必须有限制。 考虑以下修改:
  • Python 中的多处理同时限制运行进程的数量(Multiprocessing in Python while limiting the number of running processes)
    问题 我想同时运行 program.py 的多个实例,同时限制同时运行的实例数量(例如,限制在我的系统上可用的 CPU 内核数量)。 例如,如果我有 10 个内核并且必须总共运行 1000 次 program.py,那么在任何给定时间只会创建和运行 10 个实例。 我已经尝试过使用多处理模块、多线程和使用队列,但在我看来没有什么可以轻松实现的。 我遇到的最大问题是找到一种方法来限制同时运行的进程数。 这很重要,因为如果我一次创建 1000 个进程,它就相当于一个 fork 炸弹。 我不需要以编程方式从进程返回的结果(它们输出到磁盘),并且这些进程都彼此独立运行。 任何人都可以给我建议或示例,说明如何在 python 甚至 bash 中实现它? 我会发布到目前为止使用队列编写的代码,但它没有按预期工作,并且可能已经走上了错误的道路。 非常感谢。 回答1 我知道您提到 Pool.map 方法对您没有多大意义。 地图只是一种简单的方法,可以为其提供工作来源,并可以调用以应用于每个项目。 映射的func可以是对给定 arg 进行实际工作的任何入口点。 如果这对您来说似乎不合适,我在这里有一个关于使用生产者-消费者模式的非常详细的答案:https://stackoverflow.com/a/11196615/496445 本质上,您创建了一个队列,并启动了 N 个工人。
  • 在终端和Django或Flask的代码模块中使用python multiprocessing pool(Using python multiprocessing Pool in the terminal and in code modules for Django or Flask)
    问题 当在Python中使用以下代码在使用multiprocessing.Pool时,会有一些奇怪的行为。 from multiprocessing import Pool p = Pool(3) def f(x): return x threads = [p.apply_async(f, [i]) for i in range(20)] for t in threads: try: print(t.get(timeout=1)) except Exception: pass 我收到以下错误三遍(池中的每个线程一个),并且打印出“ 3”到“ 19”: AttributeError: 'module' object has no attribute 'f' 前三个apply_async调用永不返回。 同时,如果我尝试: from multiprocessing import Pool p = Pool(3) def f(x): print(x) p.map(f, range(20)) 我得到AttributeError 3次,外壳打印“ 6”到“ 19”,然后挂起,无法被[Ctrl] + [C]杀死 多处理文档具有以下说法: 此软件包中的功能要求子模块可以导入主模块。 这是什么意思? 为了澄清起见,我正在终端中运行代码以测试功能,但最终我希望能够将其放入Web服务器的模块中。
  • Python进程池非守护进程?(Python Process Pool non-daemonic?)
    问题 是否可以创建非守护进程的python池? 我希望一个池能够调用内部有另一个池的函数。 我想要这个,因为守护进程无法创建进程。 具体来说,它将导致错误: AssertionError: daemonic processes are not allowed to have children 例如,考虑以下情形: function_a具有运行function_b的池,该池具有运行function_c的池。 该函数链将失败,因为在守护进程中运行了function_b ,并且守护进程无法创建进程。 回答1 multiprocessing.pool.Pool类在其__init__方法中创建工作进程,使其成为守护进程并启动它们,并且无法在启动之前将其daemon属性重新设置为False (此后不再允许)。 但是您可以创建自己的multiprocesing.pool.Pool子类( multiprocessing.Pool只是一个包装函数),并替换您自己的multiprocessing.Process子类,该子类始终是非守护进程的,用于工作进程。 这是如何执行此操作的完整示例。 重要的部分是顶部的两个类NoDaemonProcess和MyPool ,最后在您的MyPool实例上调用pool.close()和pool.join() 。 #!/usr/bin/env python # -*-
  • 导致UI挂起的主线程上的iOS semaphore_wait_trap(IOS semaphore_wait_trap on main thread causing hang in UI)
    问题 我在异步(串行)工作程序队列中有一个运行时间长的函数。 我知道有时此函数会挂在特定的openCV调用中。 由于某种原因,该挂起还会导致主线程挂起。 暂停并进入调试模式时,我看到有一个调用 semaphore_wait_trap() 在主线程上(队列) 我可以在调试模式下挂起挂起的线程(我的工作人员队列),然后该陷阱消失,GUI再次在电话上响应。 取消暂停工作线程后,GUI会响应1-2秒(我怀疑直到再次激活此线程为止),然后UI再次变得无响应。 该线程不对主线程/队列进行dispatch_sync()调用 由于工作程序长时间运行,IOS是否有可能暂停主线程(“捕获”主线程)? 我可以强行将其移除吗? 我正在添加调试模式堆栈的一些打印屏幕。 挂起挂起的队列之前: 和挂线: 暂停并挂起坏队列后: 回答1 由于工作程序长时间运行,IOS是否有可能暂停主线程(“捕获”主线程)? - 不。 我认为,您的问题与绘制或更改某些UI元素有关。 并非所有功能都可以从后台线程调用(例如,必须在主线程中完成对UI元素的更改)。 在串行队列中,如果有任何方法需要更改UI元素,则必须在主线程上调用它,例如 dispatch_async(dispatch_get_main_queue(), ^{ //do some main thread job here }); ) 回答2
  • 限制python多处理中的总CPU使用率(Limit total CPU usage in python multiprocessing)
    问题 我正在使用multiprocessing.Pool.imap在Windows 7上使用Python 2.7并行运行许多独立的作业。使用默认设置,根据Windows任务管理器的测量,我的CPU总使用率固定为100%。 这使得我的代码在后台运行时无法执行任何其他工作。 我已尝试将进程数限制为CPU数减去1,如如何限制Python使用的处理器数中所述: pool = Pool(processes=max(multiprocessing.cpu_count()-1, 1) for p in pool.imap(func, iterable): ... 这确实减少了正在运行的进程总数。 但是,每个过程都需要花费更多的周期来弥补它。 因此,我的总CPU使用率仍然固定为100%。 有没有一种方法可以直接限制总的CPU使用率-而不仅仅是进程数-否则,是否有任何解决方法? 回答1 解决方案取决于您要执行的操作。 以下是一些选择: 流程优先级较低 您可以完善子流程。 这样,尽管它们仍然会占用100%的CPU,但是在启动其他应用程序时,操作系统会优先使用其他应用程序。 如果您想在笔记本电脑的后台运行繁重的计算并且不关心CPU风扇一直运行,那么可以通过psutils设置漂亮的值。 该脚本是一个测试脚本,可以在所有内核上运行足够的时间,因此您可以查看其行为。 from multiprocessing
  • 在iOS模拟器上测试时出错:无法向引导服务器注册(Error when testing on iOS simulator: Couldn't register with the bootstrap server)
    问题 当我单击UIAlertView的按钮时崩溃时,我正在模拟器上测试我的应用程序。 我在那里停止调试,对代码进行了一些更改,然后再次构建了该应用程序。 现在,当我运行应用程序时,我在控制台中收到此错误 无法在引导服务器上注册com.myApp.debug。 错误:未知错误代码。 通常,这意味着该进程的另一个实例已在运行或挂在调试器中。程序收到信号:“ SIGABRT”。 我尝试从模拟器中删除该应用程序,进行了干净的构建,但是在尝试运行该应用程序时仍然出现此错误。 我应该怎么做才能再次在模拟器上运行该应用程序? 回答1 尝试退出并重新启动模拟器? 如果“更糟”,您可以随时尝试重新启动:以我的经验,这应该可以解决。 回答2 状态:最近被视为Mac OS 10.8和Xcode 4.4。 tl; dr:这可能在两种情况下发生:在设备上运行时和在模拟器上运行时。 在设备上运行时,断开并重新连接设备似乎可以解决问题。 迈克·阿什建议 launchctl list|grep UIKitApplication|awk '{print $3}'|xargs launchctl remove 这并非一直都有效。 实际上,它对我从来没有用过,但在某些情况下显然可以使用。 只是不知道哪种情况。 因此,值得尝试。 否则,解决此问题的唯一已知方法是重新启动用户启动。 重新启动可以做到这一点,但是没有那么激烈
  • 区分Java线程和OS线程?(Distinguishing between Java threads and OS threads?)
    问题 如何区分正在运行的Java线程和本机线程? 在Linux中,每个子进程都有一个父进程,他们说0是所有进程的父进程,所有分叉的Java线程中都会有一个父线程吗? 我如何知道哪个Java线程与OS线程相关(如果Java线程派生了本机进程线程)。 Java线程和OS线程有任何命名约定吗? 可以从另一个Java代码中挂起或杀死正在运行的Java线程吗? 回答1 在Linux上,Java线程是使用本机线程实现的,因此使用线程的Java程序与使用线程的本机程序没有什么不同。 “ Java线程”只是属于JVM进程的线程。 在现代Linux系统(一个使用NPTL的系统)上,属于某个进程的所有线程都具有相同的进程ID和父进程ID,但是具有不同的线程ID。 您可以通过运行ps -eLf来查看这些ID。 PID列是进程ID,PPID列是父进程ID,LWP列是线程(LightWeight进程)ID。 “主”线程的线程ID与进程ID相同,其他线程的线程ID值也不同。 较旧的Linux系统可能使用不完全符合POSIX的“ linuxthreads”线程实现,而不是NPTL。 在linuxthreads系统上,线程具有不同的进程ID。 您可以通过将系统的C库(libc)作为独立程序运行并查看其输出中的“可用扩展”,来检查系统是否使用NPTL或linuxthreads。 应该提到“ Native POSIX
  • Python多处理和子进程的独立性(Python multiprocessing and independence of children processes)
    问题 我从python终端运行以下命令,以生成一个长时间运行的子进程: from multiprocessing.process import Process Process(target=LONG_RUNNING_FUNCTION).start() 该命令返回,并且我可以在python终端中执行其他操作,但是孩子打印的所有内容仍会打印到我的python终端会话中。 当我退出终端时(使用exit或CTRL + D ),退出命令将挂起。 如果在此挂起过程中按CTRL + C ,则子进程将终止。 如果我手动(通过posix kill命令)杀死了python终端进程,那么子进程将变成孤立的,并继续运行,其输出可能会被丢弃。 如果我使用python -c运行此代码,它将等待子级终止,并且CTRL + C会杀死父级和子级。 父母终止后,python的哪些运行配置会杀死孩子? 特别是,如果python-mod_wsgi-apache网络服务器生成子进程然后重新启动,这些子进程会被杀死吗? [另外,分离从终端产生的子进程的正确方法是什么? 有没有一种比以下方法更优雅的方法:故意在python中创建一个孤立的进程 更新:通过multiprocessing.Process生成的python子进程。在apache下运行的Web服务器的进程在重启apache时不会被杀死。 回答1
  • 【OS】Linux命令如何放到后台运行
    【OS】Linux命令如何放到后台运行linux命令后台运行 有两种方式: 1. command & : 后台运行,你关掉终端会停止运行 2. nohup command & : 后台运行,你关掉终端也会继续运行 一、 简介 Linux/Unix 区别于微软平台最大的优点就是真正的多用户,多任务。因此在任务管理上也有别具特色的管理思想。 我们知道,在 Windows 上面,我们要么让一个程序作为服务在后台一直运行,要么停止这个服务。而不能让程序在前台后台之间切换。而 Linux 提供了 fg 和bg 命令,让你轻松调度正在运行的任务。假设你发现前台运行的一个程序需要很长的时间,但是需要干其他的事情,你就可以用 Ctrl-Z ,挂起这个程序,然后可以看到系统提示: [1]+ Stopped /root/bin/rsync.sh 然后我们可以把程序调度到后台执行:(bg 后面的数字为作业号) #bg 1 [1]+ /root/bin/rsync.sh & 用 jobs 命令查看正在运行的任务: #jobs [1]+ Running /root/bin/rsync.sh & 如果想把它调回到前台运行,可以用 #fg 1 /root/bin/rsync.sh 这样,你在控制台上就只能等待这个任务完成了。 & 将指令丢到后台中去执行 [ctrl]+z 將前台任务丟到后台中暂停 jobs
  • 我如何获得故障转储(How do I obtain a crash dump)
    问题 我需要从程序获取故障转储。 我如何得到它? 该程序是用C#编写的。 崩溃转储到底是什么? 什么时候创建的? 它保存在哪里? 我该如何阅读? 回答1 由于您说的是C#,因此我假设您使用的是Windows平台。 崩溃转储或仅是转储,是特定时间点的完整内存快照和进程的其他相关系统信息。 转储可用于调试程序崩溃,挂起,内存和资源泄漏以及可能在此处未列出的更多问题。 在发生崩溃并挂起的情况下,您要从崩溃转储中获取的第一条数据将是调用堆栈。 这表示崩溃的时刻或操作被阻塞且从未返回的时刻,因此程序处于停滞状态且不执行任何操作。 对于资源泄漏,可以在一段时间内收集一个进程的多个内存转储,并检查以查看内存中增长最快的对象。 这可以帮助缩小导致泄漏的代码部分。 要了解有关调试特定问题的更多信息,我强烈推荐该博客。 有几种捕获转储文件的方法。 Procdump(http://technet.microsoft.com/zh-cn/sysinternals/dd996900.aspx) Visual Studio 2010(http://msdn.microsoft.com/zh-cn/library/vstudio/fk551230(v=vs.100).aspx) WinDbg-不错,但是比其他工具更令人生畏 使用procdump,您可以简单地执行以下操作: c:\>procdump.exe
  • Python多重处理-跟踪pool.map操作的过程(Python multiprocessing - tracking the process of pool.map operation)
    问题 我有一个执行一些模拟并以字符串格式返回数组的函数。 我想运行模拟(函数)以更改输入参数值(超过10000个可能的输入值),并将结果写入单个文件。 我正在使用多重处理,特别是pool.map函数来并行运行模拟。 由于运行仿真功能超过10000次的整个过程需要很长时间,因此我真的很想跟踪整个操作的过程。 我认为下面我当前代码中的问题是,pool.map运行该函数10000次,在这些操作过程中没有任何进程跟踪。 一旦并行处理完成了10000个模拟的运行(可能是数小时到数天),那么我将继续跟踪10000个模拟结果何时保存到文件中。因此,这实际上并不是在跟踪pool.map操作的处理。 我的代码是否有简单的修补程序,可以进行流程跟踪? def simFunction(input): # Does some simulation and outputs simResult return str(simResult) # Parallel processing inputs = np.arange(0,10000,1) if __name__ == "__main__": numCores = multiprocessing.cpu_count() pool = multiprocessing.Pool(processes = numCores) t = pool.map