แป้นพิมพ์ขัดจังหวะด้วย Multrocessing Pool ของ 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 Repro:

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

ข้อยกเว้น KeyboardInterrupt จะไม่ถูกส่งจนกว่า wait () จะส่งคืนและจะไม่ส่งคืนดังนั้นการขัดจังหวะจะไม่เกิดขึ้น KeyboardInterrupt เกือบจะขัดจังหวะการรอเงื่อนไข

โปรดทราบว่าสิ่งนี้จะไม่เกิดขึ้นหากระบุการหมดเวลา cond. waiting (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

คำตอบที่ได้รับการโหวตไม่ได้จัดการกับปัญหาหลัก แต่เป็นผลข้างเคียงที่คล้ายกัน

เจส Noller, ผู้เขียนของห้องสมุด multiprocessing อธิบายถึงวิธีการอย่างถูกต้องจัดการกับ 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()

โดยปกติโครงสร้างง่ายๆนี้ใช้ได้กับCtrl- Cบนพูล:

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

signal.signal(signal.SIGINT, signal_handle)

ตามที่ระบุไว้ในโพสต์ที่คล้ายกัน:

จับแป้นพิมพ์ขัดจังหวะใน Python โดยไม่ต้องพยายามยกเว้น

ดูเหมือนว่ามีสองประเด็นที่ทำให้เกิดข้อยกเว้นในขณะที่การประมวลผลหลายขั้นตอนน่ารำคาญ สิ่งแรก (บันทึกโดย Glenn) คือคุณต้องใช้map_asyncกับการหมดเวลาแทนmapเพื่อให้ได้รับคำตอบทันที (กล่าวคือไม่ต้องดำเนินการกับรายการทั้งหมดให้เสร็จสิ้น) ประการที่สอง (บันทึกโดย Andrey) คือการประมวลผลหลายกระบวนการไม่พบข้อยกเว้นที่ไม่ได้รับมาจาก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

ฉันพบว่าในขณะนี้วิธีแก้ปัญหาที่ดีที่สุดคืออย่าใช้คุณสมบัติมัลติโพรเซสซิง. พูล แต่จะเปิดฟังก์ชันพูลของคุณเอง ฉันให้ตัวอย่างที่สาธิตข้อผิดพลาดด้วย apply_async รวมทั้งตัวอย่างที่แสดงวิธีหลีกเลี่ยงการใช้ฟังก์ชันพูลทั้งหมด

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

คุณสามารถลองใช้เมธอด 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}

ฉันเป็นมือใหม่ใน 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()ไม่เคยดูเหมือนจะดำเนินการ

น่าแปลกที่ดูเหมือนว่าคุณต้องจัดการKeyboardInterruptกับเด็ก ๆ ด้วยเช่นกัน ฉันคาดหวังว่าสิ่งนี้จะทำงานได้ตามที่เขียน ... ลองเปลี่ยนslowly_squareเป็น:

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

สิ่งนี้ควรได้ผลตามที่คุณคาดไว้