वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग · पाठ

सुदृढ़ त्रुटि प्रबंधन

विफलताओं को शालीनता से प्रबंधित करने के लिए try/catch, एग्ज़िट संकेतों और एग्ज़िट ट्रैपिंग का उपयोग करते हुए रणनीतिक त्रुटि प्रबंधन लागू करें

पाठ 2, कुल 4 में से11 चरण

सुदृढ़ त्रुटि प्रबंधन, CoddyKit पर वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

Erlang का त्रुटि-दर्शन

Erlang अपनी त्रुटि-सहिष्णुता के लिए प्रसिद्ध है। यह सभी त्रुटियों को रोककर हासिल नहीं की जाती, बल्कि उन्हें अपेक्षित मानकर और ऐसी प्रणालियाँ बनाकर हासिल की जाती है जो सहजता से उबर सकें। जहाँ उचित हो, वहाँ हम “इसे क्रैश होने दें” विचार अपनाते हैं और पर्यवेक्षकों को विफलताओं को संभालने देते हैं।

आंतरिक त्रुटियों को पकड़ना

एकल प्रक्रिया के भीतर होने वाली त्रुटियों के लिए Erlang try...catch संरचना प्रदान करता है। यह अमान्य फ़ंक्शन तर्क, फ़ाइल न मिलने की त्रुटियों या अनुप्रयोग-विशिष्ट अपवादों जैसी अपेक्षित, सीमित समस्याओं को संभालने के लिए उपयोगी है।

यह अन्य भाषाओं में अपवाद संभालने जैसा ही काम करता है, लेकिन अलग-अलग प्रक्रियाओं के बीच होने वाली विफलताओं को संभालने के लिए इसका उपयोग कम किया जाता है।

`try...catch` का व्यवहार में उपयोग

आइए एक सरल गणना में try...catch देखते हैं। यदि कोई त्रुटि होती है, तो हम उसे पकड़कर वैकल्पिक उपाय दे सकते हैं या उसका अभिलेखन कर सकते हैं। ध्यान दें कि शून्य से भाग देने के लिए हम error:badarith से मिलान करते हैं।

-module(calculator).
-export([safe_divide/2]).

safe_divide(A, B) ->
    try A / B of
        Result -> {ok, Result}
    catch
        error:badarith ->
            {error, division_by_zero}
    end.

% To run in shell:
% calculator:safe_divide(10, 2).
% calculator:safe_divide(10, 0).

विभिन्न अपवादों से मिलान

Erlang का try...catch विभिन्न प्रकार के अपवादों से मिलान करने देता है:

throw: अपेक्षित स्थितियों के लिए, जिसका उपयोग अक्सर गहरे फ़ंक्शन आह्वानों से बाहर निकलने के लिए किया जाता है।
exit: जब कोई प्रक्रिया समाप्त होती है, जैसे exit(Reason)।
error: अप्रत्याशित रनटाइम समस्याओं के लिए, जैसे शून्य से भाग देना या अपरिभाषित फ़ंक्शन आह्वान।

हर प्रकार को अलग-अलग तरीके से पकड़ा और संभाला जा सकता है।

-module(exception_matcher).
-export([test_catch/1]).

test_catch(Val) ->
    try
        case Val of
            throw_it -> throw(something_thrown);
            exit_it  -> exit(something_exited);
            error_it -> 1 / 0;
            _        -> "no error"
        end
    catch
        throw:something_thrown -> {caught, thrown};
        exit:something_exited  -> {caught, exited};
        error:badarith         -> {caught, error_badarith};
        _                      -> {caught, unknown}
    end.

% To run in shell:
% exception_matcher:test_catch(throw_it).
% exception_matcher:test_catch(exit_it).
% exception_matcher:test_catch(error_it).

एग्ज़िट संकेत: Erlang का मूल आधार

आंतरिक त्रुटियों के लिए `try...catch` के अलावा, Erlang प्रक्रियाएँ एग्ज़िट संकेतों का उपयोग करके अपनी समाप्ति के बारे में संचार करती हैं। जब कोई प्रक्रिया समाप्त होती है (चाहे सहज रूप से या किसी त्रुटि के कारण), तो वह उन सभी प्रक्रियाओं को एग्ज़िट संकेत भेजती है जिनसे वह लिंक की गई है।

यह व्यवस्था Erlang में त्रुटि-सहिष्णु प्रणालियाँ बनाने के लिए मूलभूत है।

लिंक एग्ज़िट संकेतों का प्रसार करते हैं

डिफ़ॉल्ट रूप से, यदि दो प्रक्रियाएँ लिंक की गई हों और उनमें से एक normal के अलावा किसी एग्ज़िट संकेत के साथ समाप्त हो, तो दूसरी लिंक की गई प्रक्रिया भी उसी कारण से समाप्त हो जाएगी। यह Erlang के “इसे क्रैश होने दें” दर्शन का व्यवहारिक रूप है।

यह प्रसार पर्यवेक्षकों को पूरी उप-प्रणालियों का पता लगाकर उन्हें पुनः आरंभ करने देता है और यह सुनिश्चित करता है कि विफलताओं से असंगत या अनाथ स्थिति पीछे न छूटे।

`process_flag` के साथ एग्ज़िट संकेतों को संदेशों में बदलना

कभी-कभी किसी प्रक्रिया को स्वयं क्रैश होने के बजाय लिंक की गई प्रक्रिया के समाप्त होने को संभालना पड़ता है। इसे “एग्ज़िट संकेतों को संदेशों में बदलना” कहा जाता है। कोई प्रक्रिया अपने trap_exit फ़्लैग को true पर सेट कर सकती है।

जब trap_exit का मान true होता है, तो लिंक की गई प्रक्रियाओं से आने वाले एग्ज़िट संकेत संदेशों में बदलकर उन संदेशों को संकेतों को संदेशों में बदलने वाली प्रक्रिया के मेलबॉक्स में भेज दिया जाता है।

लिंक की गई प्रक्रिया की समाप्ति संभालना

यह उदाहरण दिखाता है कि एक “पैरेंट” प्रक्रिया किसी “कार्यकर्ता” से लिंक करती है। पैरेंट trap_exit को true पर सेट करती है। जब कार्यकर्ता क्रैश होता है, तो पैरेंट क्रैश नहीं होती, बल्कि उसे {'EXIT', Pid, Reason} संदेश प्राप्त होता है, जिसे वह आगे संसाधित कर सकती है।

-module(exit_trap_demo).
-export([start/0, worker/0]).

start() ->
    ParentPid = self(),
    WorkerPid = spawn_link(fun() -> worker() end),
    process_flag(trap_exit, true), % Parent traps exits
    io:format("Parent (~p) linked to Worker (~p)~n", [ParentPid, WorkerPid]),
    receive
        {'EXIT', WorkerPid, Reason} ->
            io:format("Parent caught worker exit: ~p~n", [Reason]),
            {worker_died, Reason}
    after 5000 ->
        io:format("Parent timed out waiting for worker exit.~n"),
        timeout
    end.

worker() ->
    io:format("Worker (~p) starting...~n", [self()]),
    timer:sleep(1000), % Do some work
    exit(bad_calculation). % Worker crashes

% To run in shell:
% exit_trap_demo:start().

अपनी रणनीति चुनना

आपको एग्ज़िट संकेतों को संदेशों में कब बदलना चाहिए और उन्हें क्रैश कब होने देना चाहिए?

इसे क्रैश होने दें (डिफ़ॉल्ट): तब उपयोग करें जब एक प्रक्रिया की विफलता का अर्थ हो कि पूरा घटक प्रभावित हो गया है। पर्यवेक्षक पुनः आरंभ करने की प्रक्रिया संभालेंगे।
एग्ज़िट संकेतों को संदेशों में बदलें: तब उपयोग करें जब किसी प्रक्रिया को संसाधनों की सफ़ाई करनी हो, घटना का अभिलेखन करना हो या लिंक की गई प्रक्रिया की विफलता से उबरने का प्रयास करना हो, बिना स्वयं समाप्त हुए। इसका उपयोग अक्सर पर्यवेक्षक स्वयं करते हैं।

त्वरित जाँच

ऐसी स्थिति पर विचार करें जहाँ process_A, process_B से लिंक की गई है। process_B error_condition कारण के साथ क्रैश हो जाती है।

इंटरैक्टिव पाठ में इसका उत्तर दें

मजबूत त्रुटि-प्रबंधन का सारांश

हमने Erlang की प्रमुख त्रुटि-प्रबंधन रणनीतियों का अध्ययन किया:

एकल प्रक्रिया के भीतर सीमित, आंतरिक अपवादों के लिए try...catch।
लिंक के माध्यम से प्रक्रियाओं के बीच विफलता की सूचना देने के प्राथमिक तंत्र के रूप में एग्ज़िट संकेत।
process_flag(trap_exit, true) का उपयोग करके एग्ज़िट संकेतों को संदेशों में बदलना, जिससे कोई प्रक्रिया स्वयं क्रैश हुए बिना लिंक की गई प्रक्रिया की समाप्ति पर प्रतिक्रिया दे सकती है।

लचीली और त्रुटि-सहिष्णु Erlang प्रणालियाँ बनाने के लिए इन व्यवस्थाओं को समझना अत्यंत आवश्यक है।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Erlang सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “सुदृढ़ त्रुटि प्रबंधन” पाठ निःशुल्क है?

हाँ — वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “सुदृढ़ त्रुटि प्रबंधन” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“सुदृढ़ त्रुटि प्रबंधन” में मैं क्या सीखूँगा?

विफलताओं को शालीनता से प्रबंधित करने के लिए try/catch, एग्ज़िट संकेतों और एग्ज़िट ट्रैपिंग का उपयोग करते हुए रणनीतिक त्रुटि प्रबंधन लागू करें आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“सुदृढ़ त्रुटि प्रबंधन” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← वितरित और विफलता-सहिष्णु प्रणालियों की Erlang OTP प्रोग्रामिंग पर वापस जाएँ