Klavye python'un çoklu işleme havuzuyla kesintiye uğradı

KeyboardInterrupt olaylarını python'un çok işlem havuzlarıyla nasıl işleyebilirim? İşte basit bir örnek:

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()

Yukarıdaki kodu çalıştırırken, KeyboardInterruptbastığımda yükselir ^C, ancak süreç o noktada asılı kalır ve harici olarak öldürmek zorundayım.

^Cİstediğim zaman basabilmek ve tüm süreçlerin zarif bir şekilde çıkmasına neden olmak istiyorum .

Bu bir Python hatası. Threading.Condition.wait () öğesinde bir koşul beklenirken, KeyboardInterrupt hiçbir zaman gönderilmez. Yeniden oluşturma:

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

KeyboardInterrupt istisnası wait () geri dönünceye kadar teslim edilmez ve asla geri gelmez, bu nedenle kesinti asla gerçekleşmez. KeyboardInterrupt bir koşul beklemesini neredeyse kesmelidir.

Bir zaman aşımı belirtilirse bunun gerçekleşmeyeceğini unutmayın; cond.wait (1) kesmeyi derhal alacaktır. Bu nedenle, bir geçici çözüm bir zaman aşımı belirtmektir. Bunu yapmak için değiştirin

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

ile

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

veya benzeri.

Son zamanlarda bulduğumdan en iyi çözüm, SIGINT'i tamamen yok saymak ve tüm temizleme kodunu üst işlemle sınırlamak için çalışan işlemleri ayarlamaktır. Bu, hem boşta hem de meşgul çalışan işlemleri için sorunu giderir ve alt işlemlerinizde hata işleme kodu gerektirmez.

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()

Açıklama ve tam örnek kodu sırasıyla http://noswap.com/blog/python-multiprocessing-keyboardinterrupt/ ve http://github.com/jreese/multiprocessing-keyboardinterrupt adresinde bulunabilir .

Bazı nedenlerden dolayı, yalnızca temel Exceptionsınıftan devralınan özel durumlar normal şekilde ele alınır. Geçici bir çözüm KeyboardInterruptolarak, Exceptionörnek olarak yeniden yükseltebilirsiniz :

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()

Normalde aşağıdaki çıktıyı alırsınız:

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

Eğer vurursanız ^C, alacaksınız:

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

Genellikle bu basit yapı için çalışır Ctrl- CPool tarih:

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

signal.signal(signal.SIGINT, signal_handle)

Birkaç benzer gönderide belirtildiği gibi:

Python'da denemeden klavye kesintisini yakalayın

Oylanan cevap temel meseleyi değil, benzer bir yan etkiyi de ele alıyor.

Çok işlemcili kütüphanenin yazarı Jesse Noller, multiprocessing.Pooleski bir blog yazısında kullanırken CTRL + C ile nasıl doğru bir şekilde başa çıkılacağını açıklar .

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()

Can sıkıcı çok işlem yaparken istisna yapan iki sorun var gibi görünüyor. Birincisi (Glenn tarafından not edildi), anında yanıt almak için map_asyncbir zaman aşımı ile kullanmanız gerektiğidir map(yani, tüm listeyi işlemeyi bitirmeyin). İkincisi (Andrey tarafından not edilmiştir), çok işlemciliğin miras almayan istisnaları yakalamadığıdır Exception(örn SystemExit.). İşte her ikisiyle de ilgilenen çözümüm:

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

Şimdilik en iyi çözüm multiprocessing.pool özelliğini kullanmak değil, kendi havuz işlevlerinizi yuvarlamaktır. Apply_async ile hatayı gösteren bir örnek yanı sıra havuz işlevselliğini tamamen kullanmaktan kaçınmayı gösteren bir örnek sağladım.

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

Ben Python'da bir acemi. Ben her yerde bu ve diğer bloglar ve youtube videoları cevap ve yanılmak için bakıyordu. Yukarıdaki yazarın kodunu yapıştırın ve Windows 7 64-bit benim python 2.7.13 kopyalamak çalıştı. Neyi başarmak istediğime yakın.

Çocuk süreçlerimi ControlC'yi görmezden gelmek ve ebeveyn sürecinin sona ermesini sağlamak için yaptım. Çocuk sürecini atlamak benim için bu sorunu önlüyor gibi görünüyor.

#!/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()

Başlangıç ​​bölümü pool.terminate()hiçbir zaman yürütülmüyor gibi görünüyor.

Aşağıdaki gibi bir Pool nesnesinin Apply_async yöntemini kullanmayı deneyebilirsiniz:

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)

Çıktı:

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

Bu yöntemin bir avantajı, kesinti öncesinde işlenen sonuçların sonuç sözlüğünde döndürülmesidir:

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

Garip bir şekilde KeyboardInterrupt, çocuklarda da ele almanız gerekiyor gibi görünüyor . Ben yazıldığı gibi çalışması için bu umuyordum ... değiştirmeyi deneyin slowly_squareiçin:

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

Bu beklediğiniz gibi çalışmalı.