Клавіатура Переривається з багатопроцесорним пулом python

Як я можу обробляти події KeyboardInterrupt за допомогою багатопроцесорних пулів python? Ось простий приклад:

from multiprocessing import Pool
from time import sleep
from sys import exit

def slowly_square(i):
    sleep(1)
    return i*i

def go():
    pool = Pool(8)
    try:
        results = pool.map(slowly_square, range(40))
    except KeyboardInterrupt:
        # **** THIS PART NEVER EXECUTES. ****
        pool.terminate()
        print "You cancelled the program!"
        sys.exit(1)
    print "\nFinally, here are the results: ", results

if __name__ == "__main__":
    go()

При запуску коду вище, KeyboardInterruptпіднімається, коли я натискаю ^C, але процес просто зависає в цій точці, і я мушу вбити його зовні.

Я хочу мати можливість натиснути ^Cв будь-який час і змусити всі процеси витончено вийти.

Це помилка Python. Очікуючи умови в threading.Condition.wait (), KeyboardInterrupt ніколи не надсилається. Репро:

import threading
cond = threading.Condition(threading.Lock())
cond.acquire()
cond.wait(None)
print "done"

Виняток KeyboardInterrupt не буде доставлений, поки не повернеться wait (), і він ніколи не повернеться, тому переривання ніколи не відбудеться. KeyboardInterrupt повинен майже напевно перервати стан очікування.

Зверніть увагу, що цього не відбувається, якщо вказано час очікування; cond.wait (1) отримає перерву негайно. Таким чином, вирішення завдання полягає у визначенні тайм-ауту. Для цього замініть

    results = pool.map(slowly_square, range(40))

з

    results = pool.map_async(slowly_square, range(40)).get(9999999)

або подібне.

З того, що я нещодавно знайшов, найкращим рішенням є налаштування робочих процесів, щоб ігнорувати SIGINT взагалі і обмежити весь код очищення батьківським процесом. Це виправляє проблему як для простою, так і для зайнятих робочих процесів, і не потребує коду обробки помилок у ваших дочірніх процесах.

import signal

...

def init_worker():
    signal.signal(signal.SIGINT, signal.SIG_IGN)

...

def main()
    pool = multiprocessing.Pool(size, init_worker)

    ...

    except KeyboardInterrupt:
        pool.terminate()
        pool.join()

Пояснення та повний приклад коду можна знайти за посиланням http://noswap.com/blog/python-multiprocessing-keyboardinterrupt/ та http://github.com/jreese/multiprocessing-keyboardinterrupt відповідно.

З деяких причин Exceptionнормально обробляються лише винятки, успадковані від базового класу. Як вирішення, ви можете знову підняти свою копію KeyboardInterruptяк Exceptionекземпляр:

from multiprocessing import Pool
import time

class KeyboardInterruptError(Exception): pass

def f(x):
    try:
        time.sleep(x)
        return x
    except KeyboardInterrupt:
        raise KeyboardInterruptError()

def main():
    p = Pool(processes=4)
    try:
        print 'starting the pool map'
        print p.map(f, range(10))
        p.close()
        print 'pool map complete'
    except KeyboardInterrupt:
        print 'got ^C while pool mapping, terminating the pool'
        p.terminate()
        print 'pool is terminated'
    except Exception, e:
        print 'got exception: %r, terminating the pool' % (e,)
        p.terminate()
        print 'pool is terminated'
    finally:
        print 'joining pool processes'
        p.join()
        print 'join complete'
    print 'the end'

if __name__ == '__main__':
    main()

Зазвичай ви отримаєте такий результат:

staring the pool map
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
pool map complete
joining pool processes
join complete
the end

Тож якщо ви потрапите ^C, ви отримаєте:

staring the pool map
got ^C while pool mapping, terminating the pool
pool is terminated
joining pool processes
join complete
the end

Зазвичай ця проста структура працює для Ctrl- Cв Pool:

def signal_handle(_signal, frame):
    print "Stopping the Jobs."

signal.signal(signal.SIGINT, signal_handle)

Як було сказано в кількох подібних дописах:

Захоплення клавіатури переривання в Python без спроб за винятком

Проголосована відповідь стосується не основного питання, а подібного побічного ефекту.

Джессі Ноллер, автор багатопроцесорної бібліотеки, пояснює, як правильно боротися з CTRL + C при використанні multiprocessing.Poolв старому дописі блогу .

import signal
from multiprocessing import Pool


def initializer():
    """Ignore CTRL+C in the worker process."""
    signal.signal(signal.SIGINT, signal.SIG_IGN)


pool = Pool(initializer=initializer)

try:
    pool.map(perform_download, dowloads)
except KeyboardInterrupt:
    pool.terminate()
    pool.join()

Здається, є два питання, які роблять винятки, при цьому багатопроцесорні дратівливі. Перший (зазначив Гленн) полягає в тому, що вам потрібно скористатися map_asyncз таймаутом замість mapтого, щоб отримати негайну відповідь (тобто не закінчувати обробку всього списку). Друга (зазначила Андрій) полягає в тому, що багатопроцесорна робота не сприймає винятків, які не успадковуються Exception(наприклад, SystemExit). Тож ось моє рішення, яке стосується обох цих питань:

import sys
import functools
import traceback
import multiprocessing

def _poolFunctionWrapper(function, arg):
    """Run function under the pool

    Wrapper around function to catch exceptions that don't inherit from
    Exception (which aren't caught by multiprocessing, so that you end
    up hitting the timeout).
    """
    try:
        return function(arg)
    except:
        cls, exc, tb = sys.exc_info()
        if issubclass(cls, Exception):
            raise # No worries
        # Need to wrap the exception with something multiprocessing will recognise
        import traceback
        print "Unhandled exception %s (%s):\n%s" % (cls.__name__, exc, traceback.format_exc())
        raise Exception("Unhandled exception: %s (%s)" % (cls.__name__, exc))

def _runPool(pool, timeout, function, iterable):
    """Run the pool

    Wrapper around pool.map_async, to handle timeout.  This is required so as to
    trigger an immediate interrupt on the KeyboardInterrupt (Ctrl-C); see
    http://stackoverflow.com/questions/1408356/keyboard-interrupts-with-pythons-multiprocessing-pool

    Further wraps the function in _poolFunctionWrapper to catch exceptions
    that don't inherit from Exception.
    """
    return pool.map_async(functools.partial(_poolFunctionWrapper, function), iterable).get(timeout)

def myMap(function, iterable, numProcesses=1, timeout=9999):
    """Run the function on the iterable, optionally with multiprocessing"""
    if numProcesses > 1:
        pool = multiprocessing.Pool(processes=numProcesses, maxtasksperchild=1)
        mapFunc = functools.partial(_runPool, pool, timeout)
    else:
        pool = None
        mapFunc = map
    results = mapFunc(function, iterable)
    if pool is not None:
        pool.close()
        pool.join()
    return results

Наразі я знайшов, що найкращим рішенням є не використовувати функцію multiprocessing.pool, а скоріше скрутити власну функціональність пулу. Я наводив приклад, що демонструє помилку у Apply_async, а також приклад, який показує, як взагалі не використовувати функціональність пулу.

http://www.bryceboe.com/2010/08/26/python-multiprocessing-and-keyboardinterrupt/

Я новачок у Python. Я всюди шукав відповіді і натрапляв на це та кілька інших блогів та відео YouTube. Я спробував скопіювати вищезазначений авторський код та відтворити його на своєму python 2.7.13 у Windows 7 64-розрядному. Це близько до того, що я хочу досягти.

Я змусив своїх дочірніх процесів ігнорувати ControlC і змусив батьківський процес припинити. Схоже, що обхід дитячого процесу уникає цієї проблеми для мене.

#!/usr/bin/python

from multiprocessing import Pool
from time import sleep
from sys import exit


def slowly_square(i):
    try:
        print "<slowly_square> Sleeping and later running a square calculation..."
        sleep(1)
        return i * i
    except KeyboardInterrupt:
        print "<child processor> Don't care if you say CtrlC"
        pass


def go():
    pool = Pool(8)

    try:
        results = pool.map(slowly_square, range(40))
    except KeyboardInterrupt:
        pool.terminate()
        pool.close()
        print "You cancelled the program!"
        exit(1)
    print "Finally, here are the results", results


if __name__ == '__main__':
    go()

Частина, що починається pool.terminate()ніколи, здається, не виконується.

Ви можете спробувати скористатися методом apply_async об'єкта Pool, наприклад таким:

import multiprocessing
import time
from datetime import datetime


def test_func(x):
    time.sleep(2)
    return x**2


def apply_multiprocessing(input_list, input_function):
    pool_size = 5
    pool = multiprocessing.Pool(processes=pool_size, maxtasksperchild=10)

    try:
        jobs = {}
        for value in input_list:
            jobs[value] = pool.apply_async(input_function, [value])

        results = {}
        for value, result in jobs.items():
            try:
                results[value] = result.get()
            except KeyboardInterrupt:
                print "Interrupted by user"
                pool.terminate()
                break
            except Exception as e:
                results[value] = e
        return results
    except Exception:
        raise
    finally:
        pool.close()
        pool.join()


if __name__ == "__main__":
    iterations = range(100)
    t0 = datetime.now()
    results1 = apply_multiprocessing(iterations, test_func)
    t1 = datetime.now()
    print results1
    print "Multi: {}".format(t1 - t0)

    t2 = datetime.now()
    results2 = {i: test_func(i) for i in iterations}
    t3 = datetime.now()
    print results2
    print "Non-multi: {}".format(t3 - t2)

Вихід:

100
Multiprocessing run time: 0:00:41.131000
100
Non-multiprocessing run time: 0:03:20.688000

Перевагою цього методу є те, що результати, оброблені до переривання, будуть повернуті в словник результатів:

>>> apply_multiprocessing(range(100), test_func)
Interrupted by user
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Як не дивно, схоже, що вам доведеться впоратися і KeyboardInterruptз дітьми. Я б очікував, що це працює так, як написано ... спробуйте змінити slowly_square:

def slowly_square(i):
    try:
        sleep(1)
        return i * i
    except KeyboardInterrupt:
        print 'You EVIL bastard!'
        return 0

Це повинно працювати так, як ви очікували.