दिलचस्प पोस्ट
Form2 से form2 में टेक्स्टबॉक्स को अपडेट कैसे करें? अजीब संकलक चेतावनी सी: चेतावनी: 'struct' पैरामीटर सूची में घोषित सबसे तेज़ कौन है? `तालिका` से SQL_CALC_FOUND_ROWS का चयन करें, या SELECT COUNT (*) उदाहरण चर बनाम प्रतीक रेल पर रूबी (form_for) डेटाबेस से ड्रॉपडाउन सूची को पॉप्युलेट करने का सही तरीका क्या है? क्रोम, जावास्क्रिप्ट, विंडो। नए टैब में खोलें Srand को शुरू करने का अनुशंसित तरीका है? क्या NSArray, NSMutableArray, आदि पर टाइपिंग लागू करने का कोई तरीका है? कंसोल आउटपुट को एक txt फ़ाइल में कैसे लिखें जीआईटी को सूचीबद्ध करना और हटाने से कोई शाखा नहीं है (झूठ?) MFMailComposeViewController के MailComposer शीट में एक UIImage कैसे जोड़ें मैं विंडोज डेवलपमेंट मशीन का इस्तेमाल करके आईफोन के लिए कैसे विकसित कर सकता हूं? क्या मैं IN () स्थिति में एक सरणी बाँध सकता हूँ? विदेशी कुंजी के रूप में समग्र कुंजी SQL सर्वर में पिछले महीने के रिकॉर्ड प्राप्त करें

अजगर के मल्टीप्रोसेसिंग पूल के साथ कीबोर्ड इंटरप्ट

मैं अजगर के बहु प्रक्रमांक तालिकाओं के साथ कीबोर्ड इंटररप्ट ईवेंट कैसे प्रबंधित कर सकता हूं? ये रहा एक सरल उदाहरण:

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 प्रेस करने में सक्षम होना चाहता हूं और सभी प्रक्रियाओं को गर्व से बाहर निकलने के लिए कारण देता हूं।

वेब के समाधान से एकत्रित समाधान "अजगर के मल्टीप्रोसेसिंग पूल के साथ कीबोर्ड इंटरप्ट"

यह एक पायथन बग है थ्रेडिंग में शर्त की प्रतीक्षा करते वक्त। कंडीशन। वेट (), कीबोर्ड इंटररप्ट कभी भी नहीं भेजा जाता है। रेप्रो:

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

कुंजीपटल इंटरप्ट अपवाद तब तक वितरित नहीं किया जाएगा जब तक इंतजार () रिटर्न नहीं होता है, और यह कभी भी रिटर्न नहीं देता है, इसलिए इंटरप्ट कभी ऐसा नहीं होता है कीबोर्ड इंटररप्ट लगभग निश्चित रूप से एक शर्त इंतजार करना चाहिए।

ध्यान दें कि यदि ऐसा टाइमआउट निर्दिष्ट नहीं होता है तो ऐसा नहीं होता है; 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 वर्ग से विरासत में मिली 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 

आम तौर पर यह सरल संरचना पूल के लिए CtrlC पर काम करती है:

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

जैसा कि कुछ समान पदों में बताया गया था:

पायथन में कुंजीपटल इनर्रॉप्ट्रॉप को बिना प्रयास किए-को छोड़कर

ऐसा लगता है कि दो मुद्दे हैं जो अपवाद बनाते हैं जबकि परेशान बहुप्रतीकरण करते हैं। पहला (ग्लेन द्वारा नोट किया गया है) आपको तत्काल प्रतिक्रिया प्राप्त करने के लिए map बजाय समय-समय के साथ map_async का उपयोग करने की आवश्यकता है (यानी, संपूर्ण सूची को संसाधित नहीं करना)। दूसरा (एंड्री के द्वारा नोट किया गया) यह है कि SystemExit Exception नहीं SystemExit जो Exception से SystemExit नहीं करते (उदाहरण के लिए, 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/

मतदान का जवाब मुख्य मुद्दे से नहीं निपटता बल्कि एक समान पक्ष प्रभाव पड़ता है।

मल्टीप्रोसेसिंग लाइब्रेरी के लेखक जेसी नोलर बताते हैं कि एक पुरानी ब्लॉग पोस्ट में 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() 

मैं अजगर में एक नौसिखिया हूँ मैं इस पर उत्तर और ठोकर के लिए हर जगह और कुछ अन्य ब्लॉग और यूट्यूब वीडियो देख रहा था। मैंने ऊपर लेखक के कोड को पेस्ट करने की कोशिश की है और इसे मेरे अजगर 2.7.13 पर विंडोज 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: # *** THIS PART NEVER EXECUTES. *** :( pool.terminate() pool.close() print "You cancelled the program!" exit(1) print "Finally, here are the results", results if __name__ == '__main__': go() 

अजीब तरह से ऐसा लगता है कि आप बच्चों में KeyboardInterrupt को भी संभालते हैं। मुझे उम्मीद थी कि लिखित रूप में काम करने के लिए … slowly_square करने का प्रयास करें:

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

आपको उम्मीद है कि यह काम करना चाहिए