Bàn phím bị gián đoạn với nhóm đa xử lý của python

Làm cách nào tôi có thể xử lý các sự kiện Bàn phím bị gián đoạn với Nhóm đa xử lý của python? Đây là một ví dụ đơn giản:

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

Khi chạy mã ở trên, mã KeyboardInterruptđược tăng lên khi tôi nhấn ^C, nhưng quá trình chỉ đơn giản là bị treo ở điểm đó và tôi phải giết nó bên ngoài.

Tôi muốn có thể nhấn ^Cbất cứ lúc nào và khiến tất cả các quá trình thoát ra một cách duyên dáng.

Đây là một lỗi Python. Khi chờ một điều kiện trong luồng .ondond.wait (), KeyboardInterrupt không bao giờ được gửi. Trả lời:

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

Ngoại lệ KeyboardInterrupt sẽ không được gửi cho đến khi Wait () trả về và nó không bao giờ quay trở lại, vì vậy việc ngắt không bao giờ xảy ra. Bàn phím gần như chắc chắn sẽ làm gián đoạn một điều kiện chờ đợi.

Lưu ý rằng điều này không xảy ra nếu thời gian chờ được chỉ định; cond.wait (1) sẽ nhận được ngắt ngay lập tức. Vì vậy, một cách giải quyết là chỉ định thời gian chờ. Để làm điều đó, thay thế

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

với

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

hoặc tương tự.

Từ những gì tôi đã tìm thấy gần đây, giải pháp tốt nhất là thiết lập các quy trình worker để bỏ qua SIGINT hoàn toàn và giới hạn tất cả các mã dọn dẹp cho quy trình cha. Điều này khắc phục sự cố cho cả quy trình công nhân nhàn rỗi và bận rộn và không yêu cầu mã xử lý lỗi trong các quy trình con của bạn.

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

Giải thích và mã ví dụ đầy đủ có thể được tìm thấy tại http://noswap.com/blog/python-multiprocessing-keyboardinterrupt/ và http://github.com/jreese/multiprocessing-keyboardinterrupt tương ứng.

Vì một số lý do, chỉ các ngoại lệ được kế thừa từ Exceptionlớp cơ sở được xử lý bình thường. Như một giải pháp thay thế, bạn có thể nâng cao lại KeyboardInterruptnhư một Exceptionví dụ:

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

Thông thường bạn sẽ nhận được đầu ra sau:

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

Vì vậy, nếu bạn đánh ^C, bạn sẽ nhận được:

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

Thông thường cấu trúc đơn giản này hoạt động cho Ctrl- Ctrên Pool:

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

signal.signal(signal.SIGINT, signal_handle)

Như đã nêu trong một số bài viết tương tự:

Chụp bàn phím bị gián đoạn trong Python mà không cần thử ngoại trừ

Câu trả lời được bình chọn không giải quyết vấn đề cốt lõi mà là một tác dụng phụ tương tự.

Jesse Noller, tác giả của thư viện đa xử lý, giải thích cách xử lý chính xác với CTRL + C khi sử dụng multiprocessing.Pooltrong một bài đăng trên blog cũ .

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

Có vẻ như có hai vấn đề khiến ngoại lệ trong khi xử lý nhiều vấn đề gây khó chịu. Điều đầu tiên (được Glenn lưu ý) là bạn cần sử dụng map_asyncvới thời gian chờ thay vì mapđể nhận được phản hồi ngay lập tức (nghĩa là không hoàn thành xử lý toàn bộ danh sách). Thứ hai (được ghi chú bởi Andrey) là đa xử lý không bắt được các ngoại lệ không được thừa hưởng từ Exception(ví dụ SystemExit:). Vì vậy, đây là giải pháp của tôi liên quan đến cả hai điều này:

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

Tôi thấy, hiện tại, giải pháp tốt nhất là không sử dụng tính năng multirocessing.pool mà thay vào đó là cuộn chức năng pool của riêng bạn. Tôi đã cung cấp một ví dụ minh họa lỗi với application_async cũng như một ví dụ chỉ ra cách tránh sử dụng chức năng nhóm hoàn toàn.

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

Tôi là người mới chơi Python. Tôi đã tìm kiếm khắp nơi để tìm câu trả lời và vấp phải điều này và một vài blog và video youtube khác. Tôi đã cố gắng sao chép dán mã của tác giả ở trên và sao chép nó trên python 2.7.13 của tôi trong windows 7 64-bit. Nó gần với những gì tôi muốn đạt được.

Tôi đã tạo cho con tôi các quy trình để bỏ qua ControlC và làm cho quá trình cha mẹ chấm dứt. Có vẻ như bỏ qua quá trình con không tránh được vấn đề này đối với tôi.

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

Phần bắt đầu pool.terminate()dường như không bao giờ thực hiện.

Bạn có thể thử sử dụng phương thức application_async của đối tượng Pool, như thế này:

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)

Đầu ra:

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

Một lợi thế của phương pháp này là các kết quả được xử lý trước khi gián đoạn sẽ được trả về trong từ điển kết quả:

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

Thật kỳ lạ, có vẻ như bạn cũng phải xử lý KeyboardInterruptcả trẻ em. Tôi đã mong đợi điều này sẽ hoạt động như được viết ... hãy thử đổi slowly_squarethành:

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

Điều đó sẽ làm việc như bạn mong đợi.