Python присоединяется к процессу, не блокируя родительский

Ответ 1

Вы можете настроить отдельный поток, который соединяет. Попросите его прослушать queue, в который вы нажимаете дескрипторы подпроцесса:

class Joiner(Thread):
    def __init__(self, q):
        self.__q = q
    def run(self):
        while True:
            child = self.__q.get()
            if child == None:
                return
            child.join()

Затем вместо p.join() сделайте joinq.put(p) и сделайте a joinq.put(None), чтобы сигнализировать о прекращении потока. Убедитесь, что вы используете очередь FIFO.

Ответ 2

В цикле while вызовите

multiprocessing.active_children()

Возвращает список всех живых детей текущего процесса. Вызов этого имеет побочный эффект от "присоединения" к уже завершенным процессам.

Ответ 3

Если вам не важно, когда и будет ли ребенок завершен, и вы просто хотите избежать того, чтобы ребенок закончил процесс зомби, тогда вы можете сделать двойную вилку, чтобы внук оказался ребенком init. В коде:

def child(*args):
  p = Process(target=grandchild, args=args)
  p.start()
  os._exit(0)

def grandchild(filename, wDir, dDir):
  # Open filename and extract the url
  ...
  # Download the file and to the dDir directory
  ...
  # Delete filename from the watch directory
  ...
  # exit cleanly
  os._exit(0)

Ответ 4

Вместо того, чтобы пытаться использовать shoehorn multiprocessing.Process() для работы, возможно, вам следует использовать другой инструмент, например apply_async() с многопроцессорной обработкой .Pool():

def main(argv):
    # parse command line args
    ...
    # set up variables
    ...

    # set up multiprocessing Pool
    pool = multiprocessing.Pool()

    try:
        watch_dir(watch_dir, download_dir, pool)

    # catch whatever kind of exception you expect to end your infinite loop
    # you can omit this try/except if you really think your script will 
    # run "forever" and you're okay with zombies should it crash
    except KeyboardInterrupt:
        pool.close()
        pool.join()

def watch_dir(wDir, dDir, pool):
    # Grab the current watch directory listing
    before = dict([(f, None) for f in os.listdir (wDir)])

    # Loop FOREVER
    while 1:
        # sleep for 10 secs
        time.sleep(10)

        # Grab the current dir listing
        after = dict([(f, None) for f in os.listdir (wDir)])

        # Get the list of new files
        added = [f for f in after if not f in before]
        # Get the list of deleted files
        removed = [f for f in before if not f in after]

        if added:
            # We have new files, do your stuff
            print "Added: ", ", ".join(added)

            # launch the function in a subprocess - this is NON-BLOCKING
            pool.apply_async(child, (added, wDir, dDir))

        if removed:
            # tell the user the file was deleted
            print "Removed: ", ", ".join(removed)

        # Set before to the current
        before = after

def child(filename, wDir, dDir):
    # Open filename and extract the url
    ...
    # Download the file and to the dDir directory
    ...
    # Delete filename from the watch directory
    ...
    # simply return to "exit cleanly"
    return

multiprocessing.Pool() - это пул рабочих подпроцессов, к которым вы можете отправить "задания". Вызов функции pool.apply_async() приводит к тому, что один из подпроцессов запускает вашу функцию с предоставленными аргументами асинхронно и не нуждается в объединении до тех пор, пока ваш script не будет выполнен со всей его работой и не закрывает весь пул. Библиотека управляет деталями для вас.

Я думаю, что это послужит вам лучше, чем текущий принятый ответ по следующим причинам:
1. Он устраняет ненужную сложность запуска дополнительных потоков и очередей только для управления подпроцессами.
2. Он использует библиотечные процедуры, которые сделаны специально для этой цели, поэтому вы получаете преимущества будущих улучшений в библиотеке.
3. ИМХО, он гораздо удобнее обслуживать.
4. Он более гибкий. Если однажды вы решите, что хотите увидеть возвращаемое значение из ваших подпроцессов, вы можете сохранить возвращаемое значение из вызова apply_async() (результат объекта) и проверяйте его, когда захотите. Вы можете хранить их в списке и обрабатывать их как пакет, когда ваш список превышает определенный размер. Вы можете переместить создание пула в функцию watch_dir() и покончить с try/except, если вам все равно, что произойдет, если цикл "бесконечный" будет прерван. Если вы помещаете какое-то условие прерывания в (в настоящее время) бесконечный цикл, вы можете просто добавить pool.close() и pool.join() после цикла, и все будет очищено.