Erlang Language
प्रक्रियाओं

प्रक्रियाएँ बनाना

हम spawn फ़ंक्शन को कॉल करके एक नई समवर्ती प्रक्रिया बनाते spawn । spawn फंक्शन को एक फंक्शन पैरामीटर के रूप में मिलेगा Fun कि प्रक्रिया मूल्यांकन करेगी। spawn फंक्शन का रिटर्न वैल्यू क्रिएट प्रोसेस आइडेंटिफायर (pid) है।

1> Fun = fun() -> 2+2 end.
#Fun<erl_eval.20.52032458>
2> Pid = spawn(Fun).
<0.60.0>

आप एक प्रक्रिया शुरू करने के लिए spawn/3 का भी उपयोग कर सकते हैं जो एक मॉड्यूल से एक विशिष्ट फ़ंक्शन को निष्पादित करेगा: spawn(Module, Function, Args) ।
या एक अलग नोड में एक प्रक्रिया शुरू करने के लिए spawn/2 या spawn/4 उपयोग करें: spawn(Node, Fun) या spawn(Node, Module, Function, Args) ।

संदेश देना

दो इरलांग प्रक्रियाएं एक-दूसरे के साथ संवाद कर सकती हैं, जिसे संदेश गुजरने के रूप में भी जाना जाता है।
यह प्रक्रिया इस रूप में अतुल्यकालिक है कि संदेश भेजने के बाद भेजने की प्रक्रिया रुक नहीं जाएगी।

संदेश भेजना

यह निर्माण Pid ! Message साथ प्राप्त किया जा सकता है Pid ! Message , जहां Pid और एक वैध प्रक्रिया पहचानकर्ता (पीआईडी) है Message किसी भी डेटा प्रकार के एक मूल्य है।

प्रत्येक प्रक्रिया में एक "मेलबॉक्स" होता है जिसमें प्राप्त आदेश में प्राप्त संदेश होते हैं। इस "मेलबॉक्स" को flush/0 फ़ंक्शन में बिल्ड के साथ खाली किया जा सकता है।

यदि कोई संदेश किसी गैर मौजूदा प्रक्रिया को भेजा जाता है, तो संदेश बिना किसी त्रुटि के छोड़ दिया जाएगा!

एक उदाहरण निम्नलिखित की तरह लग सकता है, जहां self/0 वर्तमान प्रक्रिया के पीआईडी देता है और pid/3 एक पीआईडी बनाता है।

1> Pidsh = self().
<0.32.0>
2> Pidsh ! hello.
hello
3> flush().
Shell got hello
ok
4> <0.32.0> ! hello.
* 1: syntax error before: ’<’
5> Pidsh2 = pid(0,32,0).
<0.32.0>
6> Pidsh2 ! hello2.
hello2
7> flush().
Shell got hello2
ok

Pid3!Pid2!Pid1!Msg साथ एक साथ कई प्रक्रियाओं में संदेश भेजना भी संभव है।

संदेश प्राप्त करना

प्राप्त संदेशों को receive निर्माण के साथ संसाधित किया जा सकता है।

receive
  Pattern1            -> exp11, .., exp1n1;
  Pattern2 when Guard -> exp21, .., exp2n2;
  ...
  Other               -> exp31, .., exp3n3;
  ...
  after Timeout       -> exp41, .., exp4n4
end

पहले और सबसे पुराने संदेश के साथ शुरू होने वाले "मेलबॉक्स" में संदेशों की तुलना Pattern जाएगी।
यदि एक पैटर्न मेल खाता है, तो मेल किया हुआ संदेश "मेलबॉक्स" से हटा दिया जाता है और खंड शरीर का मूल्यांकन किया जाता है।

निर्माण के after टाइमआउट को परिभाषित करना भी संभव है।
एक Timeout या तो मिलीसेकंड में प्रतीक्षा समय या परमाणु infinity ।

receive का रिटर्न मान अंतिम मूल्यांकित खंड निकाय है।

उदाहरण (काउंटर)

संदेश के साथ एक (बहुत) सरल काउंटर निम्नलिखित में जैसा लग सकता है।

-module(counter0).
-export([start/0,loop/1]).

% Creating the counter process.
start() ->
    spawn(counter0, loop, [0]).

% The counter loop.
loop(Val) ->
    receive
        increment ->
           loop(Val + 1)
    end.

काउंटर के साथ बातचीत।

1> C0 = counter0:start().
<0.39.0>
2> C0!increment.
increment
3> C0!increment.
increment

प्रक्रियाओं को पंजीकृत करें

एक वैश्विक उपनाम के लिए एक प्रक्रिया (पीआईडी) दर्ज करना संभव है।
इसे बिल्ड इन register(Alias, Pid) फ़ंक्शन के साथ प्राप्त किया जा सकता है, जहां Alias प्रक्रिया के रूप में एक्सेस करने के लिए परमाणु है और Pid प्रक्रिया आईडी है।

उर्फ विश्व स्तर पर उपलब्ध होगा!
साझा राज्य बनाना बहुत आसान है, जो आमतौर पर बेहतर नहीं होता है। ( यहां भी देखें )

इसके साथ एक प्रक्रिया अपंजीकृत के लिए संभव है unregister(Pid) और के साथ एक उपनाम से पीआईडी प्राप्त whereis(Alias) ।

सभी पंजीकृत उपनामों की सूची के लिए registered() उपयोग करें।

उदाहरण एटम फू को वर्तमान प्रक्रिया के पिड में पंजीकृत करता है और पंजीकृत एटम का उपयोग करके एक संदेश भेजता है।

1> register(foo, self()).
true
2> foo ! 'hello world'.
'hello world'