Elixir 1.7

Process




elixir

Process

प्रक्रियाओं और प्रक्रिया शब्दकोश के साथ काम करने के लिए सुविधा।

इस मॉड्यूल में उपलब्ध कार्यों के अलावा, Kernel मॉड्यूल कुछ बुनियादी कार्यक्षमता से संबंधित प्रक्रियाओं के माध्यम से ऑटो एक्सपोज़र और आयात करता है:

जबकि यह मॉड्यूल प्रक्रियाओं के साथ काम करने के लिए निम्न स्तर की उपयुक्तता प्रदान करता है, डेवलपर्स आमतौर पर अपने सिस्टम के निर्माण के लिए Agent , GenServer , Registry , Supervisor और Task जैसे अमूर्त का उपयोग करते हैं और जानकारी जुटाने, बाहर निकलने, लिंक और निगरानी के लिए इस मॉड्यूल का सहारा लेते हैं।

सारांश

प्रकार

dest()

एक प्रक्रिया गंतव्य

spawn_opt()
spawn_opts()

कार्य

alive?(pid)

बताता है कि दी गई प्रक्रिया स्थानीय नोड पर जीवित है या नहीं

रद्द करें_टाइमर (टाइमर_ref, विकल्प \\ [])

send_after/3 द्वारा लौटाए गए टाइमर को रद्द करता है

delete(key)

प्रक्रिया शब्दकोश से दी गई key को हटाता है

डेमनीटर (मॉनिटर_ क्रोम, विकल्प \\ [])

मॉनिटर दिए गए reference द्वारा पहचाने गए मॉनिटर

बाहर निकलें (पीआईडी, कारण)

pid को दिए गए reason साथ एक निकास संकेत भेजता है

झंडा (झंडा, मूल्य)

कॉलिंग प्रक्रिया के लिए दिए गए flag को value सेट करता है

झंडा (झंडे, झंडा, मूल्य)

दी गई प्रक्रिया के लिए value लिए दिए गए flag को सेट करता है

get()

प्रक्रिया शब्दकोश में सभी कुंजी-मूल्य जोड़े देता है

प्राप्त करें (कुंजी, डिफ़ॉल्ट \\ nil)

प्रक्रिया शब्दकोश में दिए गए key लिए मान लौटाता है, या key सेट नहीं होने पर default होता है

get_keys()

प्रक्रिया शब्दकोश में सभी चाबियाँ लौटाता है

get_keys(value)

दिए गए value वाले प्रक्रिया शब्दकोश की सभी कुंजियाँ लौटाता है

group_leader()

कॉलिंग प्रक्रिया के लिए समूह के नेता का पीआईडी ​​लौटाता है

group_leader (पीआईडी, नेता)

समूह के लीडर को दिए गए लीडर को सेट करता है

सीतनिद्रा में होना (मॉड, fun_name, args)

कॉलिंग प्रक्रिया को "हाइबरनेशन" स्थिति में डालता है

info(pid)

यदि प्रक्रिया जीवित नहीं है, तो pid द्वारा पहचान की गई प्रक्रिया के बारे में जानकारी लौटाता है या nil देता है

जानकारी (पीआईडी, कल्पना)

यदि प्रक्रिया जीवित नहीं है, तो pid द्वारा पहचान की गई प्रक्रिया के बारे में जानकारी लौटाता है या nil देता है

link(pid_or_port)

कॉलिंग प्रक्रिया और दिए गए आइटम (प्रक्रिया या पोर्ट) के बीच एक लिंक बनाता है

list()

वर्तमान में स्थानीय नोड पर मौजूद सभी प्रक्रियाओं के अनुरूप पीआईडी ​​की सूची लौटाता है

monitor(item)

कॉलिंग प्रक्रिया से दिए गए item निगरानी शुरू करता है

डाल (कुंजी, मूल्य)

प्रक्रिया शब्दकोश में दिए गए key - value युग्म को संग्रहीत करता है

read_timer(timer_ref)

send_after/3 द्वारा बनाया गया एक टाइमर पढ़ता है

रजिस्टर (pid_or_port, नाम)

दिए गए name नीचे दिए गए pid_or_port को पंजीकृत करता है

registered()

register/2 का उपयोग करके register/2 किए गए नामों की सूची लौटाता है

भेजें (भाग्य, संदेश, विकल्प)

दिए गए dest को संदेश भेजता है

send_after (भाग्य, संदेश, समय, opts \\ [])

msg भेजता है time मिलीसेकंड के बाद भाग्य

sleep(timeout)

दिए गए timeout लिए वर्तमान प्रक्रिया को सोता है

स्पॉन (मज़ा, ऑप्स)

दिए गए विकल्पों के अनुसार दिए गए फ़ंक्शन को खोलता है

स्पॉन (मॉड, मजेदार, आर्ग्स, ऑप्स)

दिए गए विकल्पों के अनुसार दिए गए args पास करते हुए, मॉड्यूल mod से दिए गए फ़ंक्शन का fun लेता है

unlink(pid_or_port)

कॉलिंग प्रक्रिया और दिए गए आइटम (प्रक्रिया या पोर्ट) के बीच के लिंक को हटा देता है

unregister(name)

एक PID या पोर्ट पहचानकर्ता से संबंधित पंजीकृत name हटाता है

whereis(name)

यदि नाम पंजीकृत नहीं है तो name या nil तहत पंजीकृत पीआईडी ​​या पोर्ट पहचानकर्ता लौटाता है

प्रकार

गंतव्य ()

dest() ::
  pid() | port() | registered_name() ::
  atom() | {registered_name :: atom(), node()}

एक प्रक्रिया गंतव्य।

एक दूरस्थ या स्थानीय पीआईडी, एक स्थानीय बंदरगाह, एक स्थानीय रूप से पंजीकृत नाम या दूसरे नोड में एक पंजीकृत नाम के लिए {registered_name, node} के रूप में एक टपल।

spawn_opt ()

spawn_opt() ::
  :link
  | :monitor
  | {:priority, :low | :normal | :high}
  | {:fullsweep_after, non_neg_integer()}
  | {:min_heap_size, non_neg_integer()}
  | {:min_bin_vheap_size, non_neg_integer()}

spawn_opts ()

spawn_opts() :: [spawn_opt()]

कार्य

जिंदा? (पीआईडी)

alive?(pid()) :: boolean()

बताता है कि दी गई प्रक्रिया स्थानीय नोड पर जीवित है या नहीं।

यदि pid द्वारा पहचानी जाने वाली प्रक्रिया जीवित है (अर्थात, यह बाहर नहीं निकल रही है और अभी तक बाहर नहीं निकली है) तो यह फ़ंक्शन true से अधिक true । अन्यथा, यह false

pid को स्थानीय नोड पर चलने वाली प्रक्रिया का संदर्भ देना चाहिए या ArgumentError को उठाया जाता है।

संकलक द्वारा झुका हुआ।

रद्द करें_टाइमर (टाइमर_ref, विकल्प \\ [])

cancel_timer(reference(), options) :: non_neg_integer() | false | :ok
when options: [async: boolean(), info: boolean()]

send_after/3 द्वारा लौटाए गए टाइमर को रद्द करता है।

जब परिणाम एक पूर्णांक होता है, तो यह टाइमर के समाप्त होने तक बचे हुए मिलीसेकंड में समय का प्रतिनिधित्व करता है।

जब परिणाम false , तो timer_ref अनुरूप टाइमर नहीं पाया जा सकता है। ऐसा या तो हो सकता है क्योंकि टाइमर की समय सीमा समाप्त हो गई है, क्योंकि यह पहले ही रद्द हो चुका है, या क्योंकि timer_ref कभी भी टाइमर के अनुरूप नहीं है।

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

संकलक द्वारा झुका हुआ।

विकल्प

  • :async - (बूलियन) जब false , तो रद्द करने का अनुरोध समकालिक है। जब true , तो रद्द करने का अनुरोध अतुल्यकालिक है, जिसका अर्थ है कि टाइमर को रद्द करने का अनुरोध जारी किया गया है और :ok है :ok है। false अवहेलना।

  • :info - (बूलियन) क्या टाइमर रद्द होने की जानकारी वापस करना है। जब :async विकल्प false और :info true , तो एक पूर्णांक या false (जैसा ऊपर वर्णित है) वापस कर दिया गया है। यदि :async false और :info false :ok है। यदि :async true और :info true , तो एक संदेश {:cancel_timer, timer_ref, result} (जहाँ result एक पूर्णांक या ऊपर जैसा false है) में संदेश इस फ़ंक्शन के कॉलर को भेजा जाता है जब रद्द किया गया हो। । यदि :async true और :info false , तो कोई संदेश नहीं भेजा गया है। true अवहेलना।

हटाना (key)

delete(term()) :: term() | nil

प्रक्रिया शब्दकोश से दी गई key को हटाता है।

प्रक्रिया शब्दकोश में key अंतर्गत आने वाला मान लौटाता है या यदि key को प्रक्रिया शब्दकोश में संग्रहीत नहीं किया जाता है।

उदाहरण

Process.put(:comments, ["comment", "other comment"])
Process.delete(:comments)
#=> ["comment", "other comment"]
Process.delete(:comments)
#=> nil

डेमनीटर (मॉनिटर_ क्रोम, विकल्प \\ [])

demonitor(reference(), options :: [:flush | :info]) :: boolean()

मॉनिटर दिए गए reference द्वारा पहचाने गए मॉनिटर।

अगर monitor_ref एक संदर्भ है जिसे कॉलिंग प्रक्रिया monitor(item) कॉल करके प्राप्त होती है, तो वह मॉनिटरिंग बंद हो जाती है। यदि निगरानी पहले से ही बंद है, तो कुछ भी नहीं होता है।

अधिक जानकारी के लिए देखें :erlang.demonitor/2

संकलक द्वारा झुका हुआ।

बाहर निकलें (पीआईडी, कारण)

exit(pid(), term()) :: true

pid को दिए गए reason साथ एक निकास संकेत भेजता है।

निम्न व्यवहार लागू होता है यदि reason को छोड़कर कोई भी शब्द है :normal या :kill :

  1. यदि pid बाहर नहीं फँस रहा है, तो pid दिए गए reason से बाहर निकल जाएगा।

  2. यदि pid बाहर निकल रहा है, तो बाहर निकलने का संकेत एक संदेश में बदल जाता है {:EXIT, from, reason} और pid के संदेश कतार में पहुंचा दिया जाता है।

यदि reason परमाणु है :normal , pid बाहर नहीं निकलेगी (जब तक कि pid कॉलिंग प्रक्रिया नहीं है, इस स्थिति में यह कारण के साथ बाहर निकल जाएगा :normal )। यदि यह बाहर निकल रहा है, तो बाहर निकलने का संकेत एक संदेश में बदल जाता है {:EXIT, from, :normal} और अपनी संदेश कतार में पहुंचाया।

यदि reason परमाणु है :kill , तो यह है कि अगर Process.exit(pid, :kill) को कहा जाता है, तो एक अयोग्य निकास संकेत को pid भेजा जाता है जो बिना कारण के बिना शर्त से बाहर निकल जाएगा :killed

संकलक द्वारा झुका हुआ।

उदाहरण

Process.exit(pid, :kill)
#=> true

झंडा (झंडा, मूल्य)

flag(:trap_exit, boolean()) :: boolean()
flag(:sensitive, boolean()) :: boolean()
flag(:save_calls, 0..10000) :: 0..10000
flag(:priority, priority_level()) :: priority_level()
flag({:monitor_nodes, term()}, term()) :: term()
flag(:monitor_nodes, term()) :: term()
flag(:min_heap_size, non_neg_integer()) :: non_neg_integer()
flag(:min_bin_vheap_size, non_neg_integer()) :: non_neg_integer()
flag(:message_queue_data, :erlang.message_queue_data()) ::
  :erlang.message_queue_data()
flag(:max_heap_size, heap_size()) :: heap_size()
flag(:error_handler, module()) :: module()

कॉलिंग प्रक्रिया के लिए दिए गए flag को value सेट करता है।

flag का पुराना मूल्य लौटाता है।

अधिक जानकारी के लिए देखें :erlang.process_flag/2

संकलक द्वारा झुका हुआ।

झंडा (झंडे, झंडा, मूल्य)

flag(pid(), :save_calls, 0..10000) :: 0..10000

दी गई प्रक्रिया के लिए value लिए दिए गए flag को सेट करता है।

flag का पुराना मूल्य लौटाता है।

यदि कोई स्थानीय प्रक्रिया नहीं है तो यह ArgumentError बढ़ाता है।

flag लिए अनुमत मूल्य केवल flag/2 में अनुमत लोगों का एक उप नाम हैं, अर्थात् :save_calls

अधिक जानकारी के लिए देखें :erlang.process_flag/3

संकलक द्वारा झुका हुआ।

प्राप्त()

get() :: [{term(), term()}]

प्रक्रिया शब्दकोश में सभी कुंजी-मूल्य जोड़े देता है।

संकलक द्वारा झुका हुआ।

प्राप्त करें (कुंजी, डिफ़ॉल्ट \\ nil)

get(term(), default :: term()) :: term()

प्रक्रिया शब्दकोश में दिए गए key लिए मान लौटाता है, या key सेट नहीं होने पर default होता है।

get_keys ()

get_keys() :: [term()]

प्रक्रिया शब्दकोश में सभी चाबियाँ लौटाता है।

संकलक द्वारा झुका हुआ।

get_keys (मान)

get_keys(term()) :: [term()]

दिए गए value वाले प्रक्रिया शब्दकोश की सभी कुंजियाँ लौटाता है।

संकलक द्वारा झुका हुआ।

समूह का नेता()

group_leader() :: pid()

कॉलिंग प्रक्रिया के लिए समूह के नेता का पीआईडी ​​लौटाता है।

संकलक द्वारा झुका हुआ।

group_leader (पीआईडी, नेता)

group_leader(pid(), leader :: pid()) :: true

समूह के लीडर को दिए गए लीडर को सेट करता है।

आमतौर पर, इसका उपयोग तब किया जाता है जब एक निश्चित शेल से शुरू की गई प्रक्रिया में एक समूह के नेता के अलावा होना चाहिए :init

संकलक द्वारा झुका हुआ।

सीतनिद्रा में होना (मॉड, fun_name, args)

hibernate(module(), atom(), list()) :: no_return()

कॉलिंग प्रक्रिया को "हाइबरनेशन" स्थिति में डालता है।

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

अधिक जानकारी के लिए देखें :erlang.hibernate/3

संकलक द्वारा झुका हुआ।

जानकारी (पीआईडी)

info(pid()) :: keyword() | nil

यदि प्रक्रिया जीवित नहीं है, तो pid द्वारा पहचान की गई प्रक्रिया के बारे में जानकारी लौटाता है या nil देता है।

यह केवल डिबगिंग जानकारी के लिए उपयोग करें।

अधिक जानकारी के लिए देखें :erlang.process_info/1

जानकारी (पीआईडी, कल्पना)

info(pid(), atom() | [atom()]) :: {atom(), term()} | [{atom(), term()}] | nil

यदि प्रक्रिया जीवित नहीं है, तो pid द्वारा पहचान की गई प्रक्रिया के बारे में जानकारी लौटाता है या nil देता है।

अधिक जानकारी के लिए देखें :erlang.process_info/2

लिंक (pid_or_port)

link(pid() | port()) :: true

कॉलिंग प्रक्रिया और दिए गए आइटम (प्रक्रिया या पोर्ट) के बीच एक लिंक बनाता है।

लिंक द्विदिश हैं। लिंक की गई प्रक्रियाओं को unlink(pid_or_port) का उपयोग करके unlink(pid_or_port) किया जा सकता है।

यदि ऐसा लिंक पहले से मौजूद है, तो यह फ़ंक्शन कुछ भी नहीं करता है क्योंकि दो दिए गए प्रक्रियाओं के बीच केवल एक लिंक हो सकता है। यदि कोई प्रक्रिया स्वयं के लिए लिंक बनाने का प्रयास करती है, तो कुछ भी नहीं होगा।

जब दो प्रक्रियाएं जुड़ी होती हैं, तो प्रत्येक को दूसरे से बाहर निकलने के संकेत मिलते हैं (देखें exit/2 )। मान pid1 कि pid1 और pid2 जुड़े हुए हैं। यदि pid2 इसके अलावा किसी अन्य कारण से बाहर निकलता है :normal (जो एक प्रक्रिया समाप्त होने पर उपयोग किया जाने वाला निकास कारण भी होता है) और pid1 बाहर नहीं जा रहा है ( flag/2 देखें), तो pid1 pid2 और उसी कारण से बाहर निकल जाएगा बारी अपने सभी अन्य जुड़े प्रक्रियाओं के लिए एक बाहर निकलने का संकेत है। जब pid1 बाहर निकल रहा है तो व्यवहार exit/2 में वर्णित है।

अधिक जानकारी के लिए देखें :erlang.link/1

संकलक द्वारा झुका हुआ।

सूची()

list() :: [pid()]

वर्तमान में स्थानीय नोड पर मौजूद सभी प्रक्रियाओं के अनुरूप पीआईडी ​​की सूची लौटाता है।

ध्यान दें कि यदि कोई प्रक्रिया बाहर निकल रही है, तो इसका अस्तित्व माना जाता है लेकिन जीवित नहीं होना चाहिए। इसका मतलब यह है कि इस तरह की प्रक्रिया के लिए, alive?(pid) false वापस आ जाएगा लेकिन इसका पीआईडी ​​इस समारोह द्वारा लौटाए गए पीआईडी ​​की सूची का हिस्सा होगा।

अधिक जानकारी के लिए देखें :erlang.processes/0

संकलक द्वारा झुका हुआ।

पर नजर रखने के (आइटम)

monitor(pid() | {name :: atom(), node :: atom()} | name() :: atom()) ::
  reference()

कॉलिंग प्रक्रिया से दिए गए item निगरानी शुरू करता है।

एक बार जब मॉनिटर की गई प्रक्रिया की मृत्यु हो जाती है, तो एक संदेश को मॉनिटरिंग प्रक्रिया में दिया जाता है:

{:DOWN, ref, :process, object, reason}

कहा पे:

  • ref इस फ़ंक्शन द्वारा दिया गया एक मॉनिटर संदर्भ है;
  • object या तो मॉनिटर की गई प्रक्रिया (यदि कोई पीआईडी ​​की निगरानी कर रहा है) या {name, node} (यदि किसी रिमोट या अन्य pid की निगरानी कर रहा है) की एक pid है;
  • reason बाहर निकलने का कारण है।

यदि Process.monitor/1 कॉल करते समय प्रक्रिया पहले से ही मृत है, तो :DOWN तुरंत संदेश डिलीवर हो जाता है।

एक उदाहरण के लिए निगरानी की आवश्यकता देखें। अधिक जानकारी के लिए देखें :erlang.monitor/2

संकलक द्वारा झुका हुआ।

डाल (कुंजी, मूल्य)

put(term(), term()) :: term() | nil

प्रक्रिया शब्दकोश में दिए गए key - value युग्म को संग्रहीत करता है।

इस फ़ंक्शन का रिटर्न मान वह मान है जिसे पहले key तहत संग्रहीत किया गया था, या nil में key तहत कोई मूल्य संग्रहीत नहीं किया गया था।

उदाहरण

# Assuming :locale was not set
Process.put(:locale, "en")
#=> nil
Process.put(:locale, "fr")
#=> "en"

read_timer (timer_ref)

read_timer(reference()) :: non_neg_integer() | false

send_after/3 द्वारा बनाया गया एक टाइमर पढ़ता है।

जब परिणाम एक पूर्णांक होता है, तो यह मिलीसेकंड में समय का प्रतिनिधित्व करता है जब तक कि टाइमर समाप्त नहीं होगा।

जब परिणाम false , तो timer_ref अनुरूप टाइमर नहीं पाया जा सकता है। यह या तो हो सकता है क्योंकि टाइमर की समय सीमा समाप्त हो गई है, क्योंकि यह पहले ही रद्द हो चुका है, या क्योंकि timer_ref कभी भी टाइमर के अनुरूप नहीं है।

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

संकलक द्वारा झुका हुआ।

रजिस्टर (pid_or_port, नाम)

register(pid() | port(), atom()) :: true

दिए गए name नीचे दिए गए pid_or_port को पंजीकृत करता है।

name एक परमाणु होना चाहिए और फिर Kernel.send/2 साथ संदेश भेजते समय PID / पोर्ट आइडेंटिफायर के बजाय उपयोग किया जा सकता है।

निम्नलिखित में से किसी भी मामले में ArgumentError साथ register/2 विफल रहेगा:

  • पीआईडी ​​/ पोर्ट स्थानीय और जीवित नहीं है
  • नाम पहले से पंजीकृत है
  • pid_or_port पहले से ही एक अलग name तहत पंजीकृत है

निम्नलिखित नाम आरक्षित हैं और न ही प्रक्रियाओं और न ही बंदरगाहों को सौंपा जा सकता है:

  • nil
  • false
  • true
  • :undefined

दर्ज कराई()

registered() :: [atom()]

register/2 का उपयोग करके register/2 किए गए नामों की सूची लौटाता है।

संकलक द्वारा झुका हुआ।

भेजें (भाग्य, संदेश, विकल्प)

send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend
when dest: dest(), msg: any(), option: :noconnect | :nosuspend

दिए गए dest को संदेश भेजता है।

dest एक दूरस्थ या स्थानीय पीआईडी ​​हो सकता है, एक स्थानीय बंदरगाह, एक स्थानीय रूप से पंजीकृत नाम, या दूसरे नोड में एक पंजीकृत नाम के लिए {registered_name, node} के रूप में टपल हो सकता है।

संकलक द्वारा झुका हुआ।

विकल्प

  • :noconnect - जब उपयोग किया जाता है, अगर संदेश भेजने के लिए एक ऑटो-कनेक्शन की आवश्यकता होती है तो दूसरे नोड को संदेश नहीं भेजा जाता है और :noconnect वापस आ जाता है।

  • :nosuspend - जब उपयोग किया जाता है, यदि संदेश भेजने पर प्रेषक को निलंबित कर दिया जाएगा तो संदेश भेजा नहीं जाता है और :nosuspend वापस आ गया है।

अन्यथा संदेश भेजा जाता है और :ok है।

उदाहरण

iex> Process.send({:name, :node_that_does_not_exist}, :hi, [:noconnect])
:noconnect

send_after (भाग्य, संदेश, समय, opts \\ [])

send_after(pid() | atom(), term(), non_neg_integer(), [option]) :: reference()
when option: {:abs, boolean()}

msg भेजता है time मिलीसेकंड के बाद भाग्य।

यदि dest एक पीआईडी ​​है, तो यह एक स्थानीय प्रक्रिया का पीआईडी ​​होना चाहिए, मृत या जीवित। यदि dest एक परमाणु है, तो यह एक पंजीकृत प्रक्रिया का नाम होना चाहिए, जिसे डिलीवरी के समय देखा जाता है। यदि नाम किसी प्रक्रिया को संदर्भित नहीं करता है, तो कोई त्रुटि उत्पन्न नहीं होती है।

यह फ़ंक्शन एक टाइमर संदर्भ देता है, जिसे read_timer(timer_ref) साथ पढ़ा जा सकता है या cancel_timer/1 साथ रद्द किया जा सकता है।

यदि दिए गए dest एक पीआईडी ​​है जो जीवित नहीं है या जब दिए गए पीआईडी ​​से बाहर निकलता है तो टाइमर स्वचालित रूप से रद्द कर दिया जाएगा। ध्यान दें कि जब dest एक परमाणु (जैसा कि परमाणु संकल्प वितरण पर किया जाता है) तब टाइमर स्वचालित रूप से रद्द नहीं किया जाएगा।

संकलक द्वारा झुका हुआ।

विकल्प

  • :abs - (बूलियन) जब false , तो time को वर्तमान मोनोटोनिक समय के सापेक्ष माना जाता है। जब true , time एर्लांग मोनोटोनिक समय का निरपेक्ष मूल्य है जिस पर msg को dest पहुंचाया जाना चाहिए। एरलांग मोनोटोनिक समय और अन्य समय से संबंधित अवधारणाओं के बारे में अधिक पढ़ने के लिए, System मॉड्यूल के लिए प्रलेखन देखें। false अवहेलना।

उदाहरण

timer_ref = Process.send_after(pid, :hi, 1000)

नींद (timeout)

sleep(timeout()) :: :ok

दिए गए timeout लिए वर्तमान प्रक्रिया को सोता है।

timeout या तो पूर्णांक या परमाणु के रूप में सोने के लिए मिलीसेकंड की संख्या है :infinity । जब :infinity दी जाती है, तो वर्तमान प्रक्रिया हमेशा के लिए सो जाएगी, और संदेशों का उपभोग या उत्तर नहीं।

इस फ़ंक्शन का उपयोग अत्यधिक सावधानी से करें । लगभग सभी स्थितियों के लिए जहां आप एलिक्सिर में sleep(timeout) उपयोग करेंगे, संदेश पासिंग के साथ ही इसे प्राप्त करने का एक अधिक सही, तेज और सटीक तरीका है।

उदाहरण के लिए, यदि आप कुछ कार्रवाई करने के लिए एक प्रक्रिया की प्रतीक्षा कर रहे हैं, तो संदेशों के साथ ऐसी कार्रवाई की प्रगति को संवाद करना बेहतर है।

दूसरे शब्दों में, नहीं :

Task.start_link fn ->
  do_something()
  ...
end

# Wait until work is done
Process.sleep(2000)

लेकिन करें :

parent = self()
Task.start_link fn ->
  do_something()
  send parent, :work_is_done
  ...
end

receive do
  :work_is_done -> :ok
after
  30_000 -> :timeout # Optional timeout
end

ऊपर दिए गए मामलों की तरह, Task.async/1 और Task.await/2 को प्राथमिकता दी जाती है।

इसी तरह, यदि आप किसी प्रक्रिया को समाप्त करने की प्रतीक्षा कर रहे हैं, तो सोने के बजाय उस प्रक्रिया की निगरानी करें। न करें :

Task.start_link fn ->
  ...
end

# Wait until task terminates
Process.sleep(2000)

इसके बजाय करें :

{:ok, pid} =
  Task.start_link fn ->
    ...
  end

ref = Process.monitor(pid)
receive do
  {:DOWN, ^ref, _, _, _} -> :task_is_down
after
  30_000 -> :timeout # Optional timeout
end

स्पॉन (मज़ा, ऑप्स)

spawn((() -> any()), spawn_opts()) :: pid() | {pid(), reference()}

दिए गए विकल्पों के अनुसार दिए गए फ़ंक्शन को खोलता है।

परिणाम दिए गए विकल्पों पर निर्भर करता है। विशेष रूप से, यदि :monitor को एक विकल्प के रूप में दिया जाता है, तो यह पीआईडी ​​और मॉनिटरिंग संदर्भ युक्त एक टपल लौटाएगा, अन्यथा बस स्पैड प्रक्रिया पीआईडी।

अधिक विकल्प उपलब्ध हैं; उपलब्ध विकल्पों की व्यापक सूची के लिए जाँच करें :erlang.spawn_opt/4

संकलक द्वारा झुका हुआ।

स्पॉन (मॉड, मजेदार, आर्ग्स, ऑप्स)

spawn(module(), atom(), list(), spawn_opts()) :: pid() | {pid(), reference()}

दिए गए विकल्पों के अनुसार दिए गए args पास करते हुए, मॉड्यूल mod से दिए गए फ़ंक्शन का fun लेता है।

परिणाम दिए गए विकल्पों पर निर्भर करता है। विशेष रूप से, यदि :monitor को एक विकल्प के रूप में दिया जाता है, तो यह पीआईडी ​​और मॉनिटरिंग संदर्भ युक्त एक टपल लौटाएगा, अन्यथा बस स्पैड प्रक्रिया पीआईडी।

यह उपलब्ध विकल्पों की सूची के लिए अतिरिक्त विकल्पों को भी स्वीकार करता है :erlang.spawn_opt/4

संकलक द्वारा झुका हुआ।

को अनलिंक (pid_or_port)

unlink(pid() | port()) :: true

कॉलिंग प्रक्रिया और दिए गए आइटम (प्रक्रिया या पोर्ट) के बीच के लिंक को हटा देता है।

यदि ऐसा कोई लिंक नहीं है, तो यह फ़ंक्शन कुछ भी नहीं करता है। यदि pid_or_port मौजूद नहीं है, तो यह फ़ंक्शन कोई त्रुटि उत्पन्न नहीं करता है और बस कुछ नहीं करता है।

इस फ़ंक्शन का रिटर्न मान हमेशा true होता true

अधिक जानकारी के लिए देखें :erlang.unlink/1

संकलक द्वारा झुका हुआ।

अपंजीकृत (नाम)

unregister(atom()) :: true

एक PID या पोर्ट पहचानकर्ता से संबंधित पंजीकृत name हटाता है।

यदि नाम किसी PID या पोर्ट पर पंजीकृत नहीं है, तो ArgumentError साथ विफल रहता है।

संकलक द्वारा झुका हुआ।

whereis (नाम)

whereis(atom()) :: pid() | port() | nil

यदि नाम पंजीकृत नहीं है तो name या nil तहत पंजीकृत पीआईडी ​​या पोर्ट पहचानकर्ता लौटाता है।

अधिक जानकारी के लिए देखें :erlang.whereis/1