प्रक्रिया ट्रैकिंग और त्रुटि हैंडलिंग, भाग 2

प्रस्तावना

इस लेख के पहले भाग में, हमने प्रक्रियाओं और त्रुटि प्रसार की प्रक्रिया के बीच संबंधों के तंत्र की जांच की। आज, आइए एक मामले को देखें जो पिछले भाग में शामिल नहीं था - हम मार संकेत के साथ प्रक्रियाओं पर शूट करते हैं।

मारने का संकेत

किल सिग्नल इंटरसेप्टेड सिग्नल नहीं है, अर्थात यह हमेशा प्रक्रिया को मारता है, भले ही यह प्रणालीगत हो। इसका उपयोग ओटीपी पर्यवेक्षक द्वारा विफल प्रक्रियाओं को समाप्त करने के लिए किया जाता है। जब कोई प्रक्रिया एक किल सिग्नल प्राप्त करती है, तो वह मर जाती है और मारे गए सिग्नल को उसके सभी लिंक पर भेज दिया जाता है।

सभी उदाहरणों में, इस प्रक्रिया के पेड़ का उपयोग किया जाएगा।


चित्र 1

एक छोटा सा मॉड्यूल लिखते हैं।

-module(test). -export([start/1, proc/2]). start(Sysproc) -> process_flag(trap_exit, Sysproc), io:format("Shell Pid: ~p~n", [self()]), PidA = spawn_link(test, proc, [self(), a]), PidB = spawn_link(test, proc, [self(), b]), io:format("ProcA: ~p~nProcB: ~p~n", [PidA, PidB]), exit(PidB, kill). proc(Shell, Tag) -> receive after 5000 -> Shell ! {hello_from, Tag, self()} end. 

प्रारंभ / 1 फ़ंक्शन में, हम दो प्रक्रियाएँ बनाते हैं: A और B, proc / 2 फ़ंक्शन प्रक्रियाओं का निकाय है, जिनमें से पहला तर्क शेल का पिड, दूसरा टैग: परमाणु () है, जो विश्लेषण में सुविधा के लिए कार्य करता है कि संदेश किस प्रक्रिया से आया है। निर्माण के बाद, निकास / 2 फ़ंक्शन को कहा जाता है, जो बी को प्रोसेस करने के लिए किल सिग्नल भेजता है।

संकलित करें और चलाएं।

 (emacs@aleksio-mobile)2> test:start(false). Shell Pid: <0.36.0> ProcA: <0.43.0> ProcB: <0.44.0> ** exception exit: killed (emacs@aleksio-mobile)3> flush(). ok (emacs@aleksio-mobile)4> self(). <0.45.0> (emacs@aleksio-mobile)5> 

हम प्रारंभ / 1 फ़ंक्शन को कॉल करते हैं (इस उदाहरण में शेल एक सिस्टम प्रक्रिया नहीं है और आउटपुट सिग्नल नहीं पकड़ सकता है)। स्पैनिंग प्रक्रियाओं के बाद, हम "** अपवाद निकास: मारे गए" संदेश देखते हैं, जिसका अर्थ है कि शेल को मारे गए कारण के साथ मारा गया था। वह खोल वास्तव में बहादुर की मौत मर गया, इसके नए पीआईडी ​​<0.45.0> कहते हैं। योजनाबद्ध रूप से, पूरी प्रक्रिया को निम्नानुसार दर्शाया जा सकता है।


चित्र 2

त्रुटि सभी लिंक के माध्यम से फैलती है और सभी प्रक्रियाएं मर जाती हैं। अब कोड को थोड़ा संशोधित करें ताकि बनाई गई प्रक्रियाओं को व्यवस्थित बनाया जा सके।

 -module(test). -export([start/1, proc/3]). start(Sysproc) -> process_flag(trap_exit, Sysproc), io:format("Shell Pid: ~p~n", [self()]), PidA = spawn_link(test, proc, [self(), a, false]), PidB = spawn_link(test, proc, [self(), b, true]), io:format("ProcA: ~p~nProcB: ~p~n", [PidA, PidB]), exit(PidB, kill). proc(Shell, Tag, Sysproc) -> process_flag(trap_exit, Sysproc), receive after 5000 -> Shell ! {hello_from, Tag, self()} end. 

 (emacs@aleksio-mobile)2> test:start(false). Shell Pid: <0.36.0> ProcA: <0.43.0> ProcB: <0.44.0> ** exception exit: killed (emacs@aleksio-mobile)3> flush(). ok (emacs@aleksio-mobile)4> self(). <0.45.0> (emacs@aleksio-mobile)5> 

इस तथ्य के बावजूद कि बी को सिस्टमिक बनाया गया था (चित्र 3 में डबल सर्कल), यह तब भी मर जाता है जब यह किल सिग्नल प्राप्त करता है, जिसके बाद मारे गए सिग्नल लिंक के माध्यम से फैलता है और सभी प्रक्रियाएं मर जाती हैं।


चित्र 3

अब शेल सिस्टम भी बनाते हैं।

 (emacs@aleksio-mobile)2> test:start(true). Shell Pid: <0.36.0> ProcA: <0.43.0> ProcB: <0.44.0> true (emacs@aleksio-mobile)3> flush(). Shell got {'EXIT',<0.44.0>,killed} Shell got {hello_from,a,<0.43.0>} Shell got {'EXIT',<0.43.0>,normal} ok (emacs@aleksio-mobile)4> self(). <0.36.0> (emacs@aleksio-mobile)5> 

हम देखते हैं कि प्रक्रिया बी को मार दिया गया था, शेल इससे बाहर निकलने के संकेत को बाधित करने में सक्षम था (शेल को {'EXIT', <0.44.0>, मारे गए}) मिला, प्रक्रिया ए ने एक संदेश भेजा और सफलतापूर्वक काम पूरा किया (चित्र 4)।


चित्र 4

यह एक और मामले का परीक्षण करने के लिए बनी हुई है।

 -module(test). -export([start/1, proc/4]). start(Sysproc) -> process_flag(trap_exit, Sysproc), io:format("Shell Pid: ~p~n", [self()]), PidA = spawn_link(test, proc, [self(), a, true, fun() -> ok end]), PidB = spawn_link(test, proc, [self(), b, false, fun() -> exit(kill) end]), io:format("ProcA: ~p~nProcB: ~p~n", [PidA, PidB]). proc(Shell, Tag, Sysproc, F) -> process_flag(trap_exit, Sysproc), F(), receive Msg -> io:format("Proc ~p get msg: ~p.~n", [Tag, Msg]) after 5000 -> Shell ! {hello_from, Tag, self()} end. 

क्रय फ़ंक्शन में एक अतिरिक्त तर्क जोड़ा गया है - एक फ़ंक्शन जिसे प्राप्त ब्लॉक से पहले बुलाया जाएगा। प्रक्रिया ए के लिए, फ़ंक्शन केवल ठीक लौटेगा, प्रक्रिया बी के लिए, यह किल पैरामीटर के साथ निकास / 1 कॉल करेगा, अर्थात। मार हम प्रक्रिया के अंदर पैदा करेंगे, और बाहर एक संकेत नहीं भेजेंगे। इस प्रयोग में प्रक्रिया ए हमेशा प्रणालीगत होगी। चेक चलाएं।

 (emacs@aleksio-mobile)2> test:start(false). Shell Pid: <0.36.0> ProcA: <0.43.0> ProcB: <0.44.0> Proc a get msg: {'EXIT',<0.36.0>,killed}. ** exception exit: killed (emacs@aleksio-mobile)3> flush(). ok (emacs@aleksio-mobile)4> self(). <0.45.0> (emacs@aleksio-mobile)5> 

हम अपने फ़ंक्शन को प्रारंभ / 1 कहते हैं (हम शेल को गैर-सिस्टम बनाते हैं), जैसा कि अपेक्षित था, शेल गिर गया। प्रोसेस बी को किल सिग्नल द्वारा मार दिया गया था, जिसके बाद सिग्नल को शेल में प्रेषित किया गया था, शेल गिर गया, फिर सिग्नल ए (प्रक्रिया 5) द्वारा पकड़ा गया।


चित्र 5

ध्यान दें सवाल! प्रक्रिया बी द्वारा शेल को क्या संकेत प्रेषित किया गया था (चित्र में तीन प्रश्न चिह्न हैं)। हत्या करने का विचार है। आइए इसे जांचें - शेल सिस्टम बनाएं।

 (emacs@aleksio-mobile)2> test:start(true). Shell Pid: <0.36.0> ProcA: <0.43.0> ProcB: <0.44.0> ok (emacs@aleksio-mobile)3> flush(). Shell got {'EXIT',<0.44.0>,kill} Shell got {hello_from,a,<0.43.0>} Shell got {'EXIT',<0.43.0>,normal} ok (emacs@aleksio-mobile)4> self(). <0.36.0> (emacs@aleksio-mobile)5> 

शेल को एक संकेत {'EXIT', <0.44.0>, मार} प्राप्त हुआ, लेकिन उसने अपना काम पूरा नहीं किया! मेरे पास तैयार उत्तर क्यों नहीं है शायद पाठकों में से एक को पता है?

अगले भाग में हम मॉनिटर के तंत्र पर विचार करेंगे।

संदर्भ

1. उत्कृष्ट ऑनलाइन प्रलेखन ।
2. फ्रांसेस्को सेसरिनी और साइमन थॉम्पसन द्वारा ERLANG प्रोग्रामिंग।
3. प्रोग्रामिंग एरलांग: जो आर्मस्ट्रांग द्वारा एक समवर्ती दुनिया के लिए सॉफ्टवेयर।