मैं पहले SIGQUIT को बच्चे के धागे में अनदेखा करने की कोशिश कर रहा हूं ... विशेष रूप से, प्रत्येक के बाद कंसोल को लिखना और दूसरी कॉल पर बाहर निकलना।

मैंने इस कोड के वेरिएंट की कोशिश की है; यानी समान स्टैक ओवरफ़्लो थ्रेड के अनुसार दो कार्यों में विभाजित करना। दुर्भाग्य से ऐसा प्रतीत होता है कि पैरेंट लूप बच्चे के हैंडलर के लिए 'बहुत तेज़' है।

SIGQUIT के लिए हैंडलर:

int goes = 0;

void install_handler(){ 

    write(1, "SIGQUIT\n", 8);

    if (goes == 1) exit(0); 

        goes += 1;
}

बस ड्राइवर:

{
    if((child_pid = fork()) < 0) exit(1);

    if (child_pid == 0 ) { 

        signal(SIGQUIT, install_handler);

        while(1){}

    } else { 

        sleep(1);

        for (int i = 0; i < 3; i++) { 

        write(1, "KILLING\n", 8);

        kill(child_pid, SIGQUIT);

      //  sleep(1);


        }
    }
    return 0;
}

मुझे उम्मीद है कि आउटपुट ~ होगा

KILLING
SIGQUIT
KILLING
SIGQUIT
KILLING
...

आउटपुट (पैरेंट लूप में नींद के बिना) है

KILLING
KILLING
KILLING
SIGQUIT
SIGQUIT

वह क्रम नहीं है जिसे मैं हासिल करने की कोशिश कर रहा हूं। यह सुनिश्चित करने का एक प्रभावी तरीका क्या है कि सिगक्विट के प्रत्येक सिग्नल पर हम गारंटी दे सकते हैं कि "सिगक्विट" main() विधि को संशोधित किए बिना कंसोल पर लिखा गया है?

0
Smiley Flower 9 अगस्त 2019, 07:12

1 उत्तर

सबसे बढ़िया उत्तर

आपके प्रश्न का एक मजेदार उत्तर है। लेकिन पहले जितना कष्टप्रद है, मुझे टिप्पणी करने की अनुमति नहीं है इसलिए मुझे आशा है कि मैं कोई गलती नहीं कर रहा हूं।

int goes = 0;
int child_pid = 0;

void install_handler(){ 
if (child_pid == 0) exit(0); //to exit the program once done
write(1, "SIGQUIT\n", 8);
kill(child_pid, SIGQUIT);
write(1, "KILLING\n", 8);
//you can put it after the if depending on the output
if (goes == 1)  {
kill(0, SIGQUIT);
exit(0);
} //this way the program will end himself at the end
// i guess the fact that goes was indented is a mistake
goes += 1;
}

जैसा कि आप देख सकते हैं कि मैंने हत्या को हैंडलर में डाल दिया है, इस तरह किल को तब तक नहीं भेजा जाएगा जब तक कि एक और किल प्राप्त न हो जाए। (ध्यान दें कि मैंने यहां पिड कैसे कहा?)

{
    if((child_pid = fork()) < 0) exit(1);

if (child_pid == 0 ) { 



    while(1){
        signal(SIGQUIT, install_handler);
    }

} else { 

    sleep(1);
    kill(child_pid, SIGQUIT);
    write(1, "KILLING\n", 8);
    for (int i = 0; i < 3; i++) { 
    signal(SIGQUIT, install_handler);
    wait(); //you might even not need the wait!


  //  sleep(1);


    }
}
return 0;

}

मैं दृढ़ता से संकेत के बजाय सिग्नेशन का उपयोग करने का सुझाव देता हूं, यह बहुत अधिक सटीक है। मुझे कहना होगा कि मुझे अपने उत्तर के बारे में निश्चित नहीं है क्योंकि मेरे पास इस कंप्यूटर पर सी नहीं है, लेकिन आमतौर पर मैं सिग्नेशन का उपयोग करता हूं और प्रतीक्षा करता हूं (नींद के बजाय) आपको इसे चाइल्ड_पिड कहने की आवश्यकता नहीं है क्योंकि यह है और नहीं है चाइल्ड पिड, क्योंकि यह दो प्रक्रिया है

बहुत... मुझे आशा है कि मैं उपयोगी था!

0
Aldric Liottier 9 अगस्त 2019, 13:00