Pythonでは、プロセスがいつ終了したかをどのように知ることができますか？

Question

Python GUI（PyGTK）内からプロセスを開始します（マルチプロセッシングを使用）。プロセスが完了するまでに長い時間がかかります（〜20分）。プロセスが終了したら、クリーンアップしたいと思いますそれをアップします（結果を抽出してプロセスに参加します）。プロセスがいつ終了したかを知るにはどうすればよいですか？

私の同僚は、子プロセスが終了したかどうかをチェックする親プロセス内のビジーループを提案しました。確かにもっと良い方法があります。

Unixでは、プロセスがフォークされると、 子プロセスが終了したときに親プロセス内からシグナルハンドラーが呼び出されます 。しかし、Pythonではそのようなものは何も表示されません。何か不足していますか？

子プロセスの終了を親プロセス内から確認できるのはなぜですか？ （もちろん、GUIインターフェイスがフリーズするため、Process.join（）を呼び出したくありません。）

この質問はマルチプロセッシングに限定されるものではありません。私はマルチスレッドでまったく同じ問題を抱えています。

Answer 1

この答えは本当に簡単です！ （それは私にかかった日それを解決するために。）

PyGTKのidle_add（）と組み合わせると、AutoJoiningThreadを作成できます。合計コードは簡単な境界線です：

class AutoJoiningThread(threading.Thread):
    def run(self):
        threading.Thread.run(self)
        gobject.idle_add(self.join)

単に参加する以上のこと（結果の収集など）を行う場合は、次の例で行うように、上記のクラスを拡張して、完了時にシグナルを発行できます。

import threading
import time
import sys
import gobject
gobject.threads_init()

class Child:
    def __init__(self):
        self.result = None

    def play(self, count):
        print "Child starting to play."
        for i in range(count):
            print "Child playing."
            time.sleep(1)
        print "Child finished playing."
        self.result = 42

    def get_result(self, obj):
        print "The result was "+str(self.result)

class AutoJoiningThread(threading.Thread, gobject.GObject):
    __gsignals__ = {
        'finished': (gobject.SIGNAL_RUN_LAST,
                     gobject.TYPE_NONE,
                     ())
        }

    def __init__(self, *args, **kwargs):
        threading.Thread.__init__(self, *args, **kwargs)
        gobject.GObject.__init__(self)

    def run(self):
        threading.Thread.run(self)
        gobject.idle_add(self.join)
        gobject.idle_add(self.emit, 'finished')

    def join(self):
        threading.Thread.join(self)
        print "Called Thread.join()"

if __name__ == '__main__':
    print "Creating child"
    child = Child()
    print "Creating thread"
    thread = AutoJoiningThread(target=child.play,
                               args=(3,))
    thread.connect('finished', child.get_result)
    print "Starting thread"
    thread.start()
    print "Running mainloop (Ctrl+C to exit)"
    mainloop = gobject.MainLoop()

    try:
        mainloop.run()
    except KeyboardInterrupt:
        print "Received KeyboardInterrupt.  Quiting."
        sys.exit()

    print "God knows how we got here.  Quiting."
    sys.exit()

上記の例の出力は、スレッドが実行される順序によって異なりますが、次のようになります。

子の作成
スレッドの作成
スレッドの開始
子の再生開始。
子の再生。
メインループの実行（Ctrl + Cで終了）
子供が遊んでいます。
子供が遊んでいます。
子供が遊んでいます。
 Thread.join（）を呼び出しました
結果は42 
 ^ CReceivedでしたKeyboardInterrupt。終了します。

同じ方法でAutoJoiningProcessを作成することはできません（2つの異なるプロセス間でidle_add（）を呼び出すことができないため）が、AutoJoiningThreadを使用して必要なものを取得できます。

class AutoJoiningProcess(multiprocessing.Process):
    def start(self):
        thread = AutoJoiningThread(target=self.start_process)
        thread.start() # automatically joins

    def start_process(self):
        multiprocessing.Process.start(self)
        self.join()

AutoJoiningProcessを示すために、別の例を示します。

import threading
import multiprocessing
import time
import sys
import gobject
gobject.threads_init()

class Child:
    def __init__(self):
        self.result = multiprocessing.Manager().list()

    def play(self, count):
        print "Child starting to play."
        for i in range(count):
            print "Child playing."
            time.sleep(1)
    print "Child finished playing."
        self.result.append(42)

    def get_result(self, obj):
        print "The result was "+str(self.result)

class AutoJoiningThread(threading.Thread, gobject.GObject):
    __gsignals__ = {
        'finished': (gobject.SIGNAL_RUN_LAST,
                     gobject.TYPE_NONE,
                     ())
    }

    def __init__(self, *args, **kwargs):
        threading.Thread.__init__(self, *args, **kwargs)
        gobject.GObject.__init__(self)

    def run(self):
        threading.Thread.run(self)
        gobject.idle_add(self.join)
        gobject.idle_add(self.emit, 'finished')

    def join(self):
        threading.Thread.join(self)
        print "Called Thread.join()"

class AutoJoiningProcess(multiprocessing.Process, gobject.GObject):
    __gsignals__ = {
        'finished': (gobject.SIGNAL_RUN_LAST,
                     gobject.TYPE_NONE,
                     ())
        }

    def __init__(self, *args, **kwargs):
        multiprocessing.Process.__init__(self, *args, **kwargs)
        gobject.GObject.__init__(self)

    def start(self):
        thread = AutoJoiningThread(target=self.start_process)
        thread.start()

    def start_process(self):
        multiprocessing.Process.start(self)
        self.join()
        gobject.idle_add(self.emit, 'finished')

    def join(self):
        multiprocessing.Process.join(self)
        print "Called Process.join()"

if __name__ == '__main__':
    print "Creating child"
    child = Child()
    print "Creating thread"
    process = AutoJoiningProcess(target=child.play,
                               args=(3,))
    process.connect('finished',child.get_result)
    print "Starting thread"
    process.start()
    print "Running mainloop (Ctrl+C to exit)"
    mainloop = gobject.MainLoop()

    try:
        mainloop.run()
    except KeyboardInterrupt:
        print "Received KeyboardInterrupt.  Quiting."
        sys.exit()

    print "God knows how we got here.  Quiting."
    sys.exit()

結果の出力は上記の例と非常に似ていますが、今回はプロセスの結合とそれに付随するスレッドの結合の両方があります。

子の作成
スレッドの作成
スレッドの開始
メインループの実行（Ctrl + Cで終了）
子の再生開始。
子の再生。
子供が遊んでいます。
子供が遊んでいます。
子供が遊んでいます。
 Process.join（）
を呼び出しました。結果は[42] 
でした。 Thread.join（）
 ^ CReceived KeyboardInterruptが呼び出されました。終了します。

残念ながら：

1. このソリューションは、idle_add（）を使用しているため、gobjectに依存しています。 gobjectはPyGTKによって使用されます。
2. これは真の親子関係ではありません。これらのスレッドの1つが別のスレッドによって開始された場合でも、親スレッドではなく、メインループを実行しているスレッドによって結合されます。この問題はAutoJoiningProcessにも当てはまりますが、例外がスローされると思います。

したがって、このアプローチを使用するには、メインループ/ GUI内からのみスレッド/プロセスを作成するのが最善です。

Answer 2

pythonマルチプラットフォームの作成の一部として、SIGCHLDのような単純なことは自分で行う必要があると思います。同意します。これは、子供がいつなのかを知りたいだけなら、もう少し作業です子プロセスを使用して作業を行う次の2つのmultiprocessing.Eventインスタンスと、子プロセスが完了したかどうかを確認するスレッドを検討します。

import threading
from multiprocessing import Process, Event
from time import sleep

def childsPlay(event):
    print "Child started"
    for i in range(3):
        print "Child is playing..."
        sleep(1)
    print "Child done"
    event.set()

def checkChild(event, killEvent):
    event.wait()
    print "Child checked, and is done playing"
    if raw_input("Do again? y/n:") == "y":
        event.clear()
        t = threading.Thread(target=checkChild, args=(event, killEvent))
        t.start()
        p = Process(target=childsPlay, args=(event,))
        p.start()
    else:
        cleanChild()
        killEvent.set()

def cleanChild():
    print "Cleaning up the child..."

if __name__ == '__main__':
    event = Event()
    killEvent = Event()

    # process to do work
    p = Process(target=childsPlay, args=(event,))
    p.start()

    # thread to check on child process
    t = threading.Thread(target=checkChild, args=(event, killEvent))
    t.start()

    try:
        while not killEvent.is_set():
            print "GUI running..."
            sleep(1)
    except KeyboardInterrupt:
        print "Quitting..."
        exit(0)
    finally:
        print "Main done"

編集

作成されたすべてのプロセスとスレッドに参加することは、ゾンビ（終了しない）プロセス/スレッドがいつ作成されているかを示すのに役立つため、良い習慣です。上記のコードを変更して、threading.Threadから継承するChildCheckerクラスを作成しました。唯一の目的は、別のプロセスでジョブを開始し、そのプロセスが完了するのを待って、すべてが完了したときにGUIに通知することです。 ChildCheckerに参加すると、「チェック」しているプロセスにも参加します。これで、プロセスが5秒後に参加しない場合、スレッドはプロセスを強制的に終了します。 「y」を入力すると、「endlessChildsPlay」を実行する子プロセスが開始され、強制終了を示す必要があります。

import threading
from multiprocessing import Process, Event
from time import sleep

def childsPlay(event):
    print "Child started"
    for i in range(3):
        print "Child is playing..."
        sleep(1)
    print "Child done"
    event.set()

def endlessChildsPlay(event):
    print "Endless child started"
    while True:
        print "Endless child is playing..."
        sleep(1)
        event.set()
    print "Endless child done"

class ChildChecker(threading.Thread):
    def __init__(self, killEvent):
        super(ChildChecker, self).__init__()
        self.killEvent = killEvent
        self.event = Event()
        self.process = Process(target=childsPlay, args=(self.event,))

    def run(self):
        self.process.start()

        while not self.killEvent.is_set():
            self.event.wait()
            print "Child checked, and is done playing"
            if raw_input("Do again? y/n:") == "y":
                self.event.clear()
                self.process = Process(target=endlessChildsPlay, args=(self.event,))
                self.process.start()
            else:
                self.cleanChild()
                self.killEvent.set()

    def join(self):
        print "Joining child process"
        # Timeout on 5 seconds
        self.process.join(5)

        if self.process.is_alive():
            print "Child did not join!  Killing.."
            self.process.terminate()
        print "Joining ChildChecker thread"
        super(ChildChecker, self).join()


    def cleanChild(self):
        print "Cleaning up the child..."

if __name__ == '__main__':
    killEvent = Event()
    # thread to check on child process
    t = ChildChecker(killEvent)
    t.start()

    try:
        while not killEvent.is_set():
            print "GUI running..."
            sleep(1)
    except KeyboardInterrupt:
        print "Quitting..."
        exit(0)
    finally:
        t.join()
        print "Main done"

Answer 3

自分の質問に対する答えを見つけようとして、PyGTKの idle_add（）関数 に出くわしました。これは私に次の可能性を与えます：

1. キューを介して通信する新しい子プロセスを作成します。
2. キューをリッスンするリスナースレッドを作成します。子プロセスがリスナーに終了を通知するメッセージを送信すると、リスナーはコールバックを設定するidle_add（）を呼び出します。
3. 次回メインループを回るときに、親プロセスがコールバックを呼び出します。
4. コールバックは結果を抽出し、子プロセスに参加し、リスナースレッドに参加できます。

これは、Unixのcall-callback-when-child-process-doneを再作成するための過度に複雑な方法のようです。

これは、PythonのGUIで非常に一般的な問題である必要があります。確かに、この問題を解決するための標準的なパターンはありますか？

Answer 4

queue を使用して、子プロセスと通信できます。中間結果、またはマイルストーンに到達したことを示すメッセージ（進行状況バーの場合）、またはプロセスが参加する準備ができていることを示すメッセージだけを貼り付けることができます。 empty でポーリングするのは簡単で高速です。

本当に完了したかどうかだけを知りたい場合は、プロセスの exitcode を監視するか、 is_alive（） をポーリングできます。

Answer 5

サブプロセスモジュールを見てください：

http://docs.python.org/library/subprocess.html

import subprocess
let pipe = subprocess.Popen("ls -l", stdout=subprocess.PIPE)
allText = pipe.stdout.read()
pipe.wait()
retVal = pipe.returncode