पाइथन

Question

में Ctrl + C/SIGINT और बाहर निकलें multiprocesses को पकड़ें मैं मल्टीप्रोसेस पायथन प्रोग्राम में Ctrl + C कैसे पकड़ूं और सभी प्रक्रियाओं से बाहर निकलता हूं, मुझे यूनिक्स और विंडोज दोनों पर काम करने का समाधान चाहिए। मैं निम्नलिखित की कोशिश की है:

import multiprocessing 
import time 
import signal 
import sys 

jobs = [] 

def worker(): 
    signal.signal(signal.SIGINT, signal_handler) 
    while(True): 
     time.sleep(1.1234) 
     print "Working..." 

def signal_handler(signal, frame): 
    print 'You pressed Ctrl+C!' 
    # for p in jobs: 
    #  p.terminate() 
    sys.exit(0) 

if __name__ == "__main__": 
    for i in range(50): 
     p = multiprocessing.Process(target=worker) 
     jobs.append(p) 
     p.start() 

और यह एक तरह से काम कर रहा है, लेकिन मैं इसे सही समाधान है नहीं लगता।

संपादित करें: यह this one

Answer 1

The previously accepted solution में दौड़ की स्थिति है और यह map और async फ़ंक्शंस के साथ काम नहीं करता है।

को संभालने के लिए सही तरीका Ctrl + C/SIGINTmultiprocessing.Pool साथ करने के लिए है:

1. प्रक्रिया एक प्रक्रिया Pool बनाई गई है पहले SIGINT उपेक्षा करें। इस तरह बाल प्रक्रियाओं को SIGINT हैंडलर का उत्तराधिकारी बनाया गया।
2. Pool के बाद मूल प्रक्रिया में मूल SIGINT हैंडलर को पुनर्स्थापित करें।
3. उपयोग map_async और बदले map और apply अवरुद्ध apply_async।
4. टाइमआउट के साथ परिणामों पर प्रतीक्षा करें क्योंकि डिफ़ॉल्ट अवरोध सभी संकेतों को अनदेखा करता है। यह पायथन बग https://bugs.python.org/issue8296 है।

यह एक साथ लाना:

#!/bin/env python 
from __future__ import print_function 

import multiprocessing 
import os 
import signal 
import time 

def run_worker(delay): 
    print("In a worker process", os.getpid()) 
    time.sleep(delay) 

def main(): 
    print("Initializng 2 workers") 
    original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN) 
    pool = multiprocessing.Pool(2) 
    signal.signal(signal.SIGINT, original_sigint_handler) 
    try: 
     print("Starting 2 jobs of 5 seconds each") 
     res = pool.map_async(run_worker, [5, 5]) 
     print("Waiting for results") 
     res.get(60) # Without the timeout this blocking call ignores all signals. 
    except KeyboardInterrupt: 
     print("Caught KeyboardInterrupt, terminating workers") 
     pool.terminate() 
    else: 
     print("Normal termination") 
     pool.close() 
    pool.join() 

if __name__ == "__main__": 
    main() 

रूप @YakovShklarov बताया गया है, संकेत अनदेखी और माता पिता की प्रक्रिया है, जिसके दौरान सिग्नल के गुम किया जा सकता है में यह अनदेखा न करने के बीच समय की एक खिड़की है। पेरेंट प्रक्रिया में सिग्नल की डिलीवरी को अस्थायी रूप से अवरुद्ध करने के बजाय pthread_sigmask का उपयोग करना सिग्नल को खोने से रोक देगा, हालांकि, यह पायथन -2 में उपलब्ध नहीं है।

Answer 2

का डुप्लिकेट समाधान this link और this link पर आधारित है हो सकता है और यह समस्या हल हो, मैं करने के लिए Pool हालांकि चला गया था:

import multiprocessing 
import time 
import signal 
import sys 

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

def worker(): 
    while(True): 
     time.sleep(1.1234) 
     print "Working..." 

if __name__ == "__main__": 
    pool = multiprocessing.Pool(50, init_worker) 
    try: 
     for i in range(50): 
      pool.apply_async(worker) 

     time.sleep(10) 
     pool.close() 
     pool.join() 

    except KeyboardInterrupt: 
     print "Caught KeyboardInterrupt, terminating workers" 
     pool.terminate() 
     pool.join() 

Answer 3

बस

अपने कार्यकर्ता प्रक्रिया में कीबोर्ड इंटरप्ट-सिस्टम एक्सीट अपवादों को संभालें:

def worker(): 
    while(True): 
     try: 
      msg = self.msg_queue.get() 
     except (KeyboardInterrupt, SystemExit): 
      print("Exiting...") 
      break