Elixir 1.7

Task.Supervisor




elixir

Task.Supervisor

एक कार्य पर्यवेक्षक।

यह मॉड्यूल एक पर्यवेक्षक को परिभाषित करता है जिसका उपयोग गतिशील रूप से पर्यवेक्षण कार्यों के लिए किया जा सकता है।

एक कार्य पर्यवेक्षक बिना बच्चों के साथ शुरू किया जाता है, अक्सर एक पर्यवेक्षक और एक नाम के तहत:

children = [
  {Task.Supervisor, name: MyApp.TaskSupervisor}
]

Supervisor.start_link(children, strategy: :one_for_one)

चाइल्ड स्पेसिफिकेशन में दिए गए विकल्प start_link/1 में प्रलेखित हैं।

अधिक उदाहरणों के लिए Task मॉड्यूल देखें।

नाम पंजीकरण

एक Task.Supervisor , Task.Supervisor के समान नाम पंजीकरण नियमों के लिए GenServer GenServer डॉक्स में उनके बारे में और पढ़ें।

सारांश

प्रकार

option()

start_link द्वारा उपयोग किए जाने वाले विकल्प मान

कार्य

async (पर्यवेक्षक, मज़ा, विकल्प \\ [])

एक कार्य शुरू करता है जिस पर प्रतीक्षा की जा सकती है

async (पर्यवेक्षक, मॉड्यूल, मज़ा, आर्ग्स, विकल्प \\ [])

एक कार्य शुरू करता है जिस पर प्रतीक्षा की जा सकती है

async_nolink (पर्यवेक्षक, मज़ा, विकल्प \\ [])

एक कार्य शुरू करता है जिस पर प्रतीक्षा की जा सकती है

async_nolink (पर्यवेक्षक, मॉड्यूल, मज़ा, आर्ग्स, विकल्प \\ [])

एक कार्य शुरू करता है जिस पर प्रतीक्षा की जा सकती है

async_stream (पर्यवेक्षक, गणना करने योग्य, मज़ेदार, विकल्प \\ [])

एक स्ट्रीम देता है जो दिए गए फ़ंक्शन को प्रत्येक आइटम पर समवर्ती fun करता fun

async_stream (पर्यवेक्षक, गणना करने योग्य, मॉड्यूल, फ़ंक्शन, आर्ग्स, विकल्प \\ [])

एक स्ट्रीम देता है जो दिए गए module , function चलाता है, और प्रत्येक आइटम पर args समरूपता में enumerable

async_stream_nolink (पर्यवेक्षक, गणना करने योग्य, मज़ेदार, विकल्प \\ []]

एक स्ट्रीम देता है जो दी गई function को प्रत्येक आइटम पर enumerable समवर्ती रूप से चलाता है

async_stream_nolink (पर्यवेक्षक, गणना करने योग्य, मॉड्यूल, फ़ंक्शन, आर्ग्स, विकल्प \\ [])

एक स्ट्रीम देता है जो दिए गए module , function चलाता है, और प्रत्येक आइटम पर args समरूपता में enumerable

children(supervisor)

सभी बच्चों को पीआईडी ​​देता है

start_child (पर्यवेक्षक, मज़ा, विकल्प \\ [])

दिए गए supervisor बच्चे के रूप में एक कार्य शुरू करता है

start_child (पर्यवेक्षक, मॉड्यूल, मज़ा, args, विकल्प \\ [])

दिए गए supervisor बच्चे के रूप में एक कार्य शुरू करता है

start_link/1

एक नया पर्यवेक्षक शुरू करता है

terminate_child (पर्यवेक्षक, पीआईडी)

दिए गए pid साथ बच्चे को टर्मिनेट करता है

प्रकार

विकल्प ()

option() ::
  Supervisor.option()
  | {:restart, :supervisor.restart()}
  | {:shutdown, :supervisor.shutdown()}

start_link द्वारा उपयोग किए जाने वाले विकल्प मान

कार्य

async (पर्यवेक्षक, मज़ा, विकल्प \\ [])

async(Supervisor.supervisor(), (() -> any()), Keyword.t()) :: Task.t()

एक कार्य शुरू करता है जिस पर प्रतीक्षा की जा सकती है।

supervisor को Task.Supervisor में परिभाषित किया जाना चाहिए। supervisor कार्य अभी भी कॉलर से जुड़ा होगा, अधिक जानकारी के लिए Task.async/3 और गैर-लिंक किए गए संस्करण के लिए async_nolink/2

विकल्प

  • :shutdown - :brutal_kill अगर कार्यों को शटडाउन पर सीधे मार दिया जाना चाहिए या एक पूर्णांक जो समयबाह्य मूल्य को दर्शाता है, तो 5000 मिलीसेकंड तक चूक हो जाती है।

async (पर्यवेक्षक, मॉड्यूल, मज़ा, आर्ग्स, विकल्प \\ [])

async(Supervisor.supervisor(), module(), atom(), [term()], Keyword.t()) ::
  Task.t()

एक कार्य शुरू करता है जिस पर प्रतीक्षा की जा सकती है।

supervisor को Task.Supervisor में परिभाषित किया जाना चाहिए। supervisor कार्य अभी भी कॉलर से जुड़ा होगा, अधिक जानकारी के लिए Task.async/3 और गैर-लिंक किए गए संस्करण के लिए async_nolink/2

विकल्प

  • :shutdown - :brutal_kill अगर कार्यों को शटडाउन पर सीधे मार दिया जाना चाहिए या एक पूर्णांक जो समयबाह्य मूल्य को दर्शाता है, तो 5000 मिलीसेकंड तक चूक हो जाती है।

async_nolink (पर्यवेक्षक, मज़ा, विकल्प \\ [])

async_nolink(Supervisor.supervisor(), (() -> any()), Keyword.t()) :: Task.t()

एक कार्य शुरू करता है जिस पर प्रतीक्षा की जा सकती है।

supervisor को Task.Supervisor में परिभाषित किया जाना चाहिए। supervisor कार्य कॉलर से लिंक नहीं किया जाएगा, अधिक जानकारी के लिए Task.async/3 देखें।

विकल्प

  • :shutdown - :brutal_kill अगर कार्यों को शटडाउन पर सीधे मार दिया जाना चाहिए या एक पूर्णांक जो समयबाह्य मूल्य को दर्शाता है, तो 5000 मिलीसेकंड तक चूक हो जाती है।

ओटीपी व्यवहार के साथ संगतता

यदि आप async_nolink जैसे OTP व्यवहार के अंदर async_nolink का उपयोग करके कोई कार्य बनाते हैं, तो आपको अपने GenServer.handle_info/2 कॉलबैक के अंदर कार्य से आने वाले संदेश पर मेल खाना चाहिए।

कार्य द्वारा भेजा गया उत्तर प्रारूप {ref, result} , जहां ref कार्य संरचना द्वारा आयोजित मॉनिटर संदर्भ है और result कार्य फ़ंक्शन का रिटर्न मान है।

ध्यान रखें कि, async_nolink के साथ बनाया गया कार्य कैसे समाप्त होता है, इस पर ध्यान दिए बिना, कॉलर की प्रक्रिया को हमेशा एक :DOWN उसी संदेश मान के साथ संदेश प्राप्त होता है, जो कार्य संरचना द्वारा होता है। यदि कार्य सामान्य रूप से समाप्त हो जाता है, तो इसका कारण :DOWN संदेश होगा :normal

async_nolink (पर्यवेक्षक, मॉड्यूल, मज़ा, आर्ग्स, विकल्प \\ [])

async_nolink(Supervisor.supervisor(), module(), atom(), [term()], Keyword.t()) ::
  Task.t()

एक कार्य शुरू करता है जिस पर प्रतीक्षा की जा सकती है।

supervisor को Task.Supervisor में परिभाषित किया जाना चाहिए। supervisor कार्य कॉलर से लिंक नहीं किया जाएगा, अधिक जानकारी के लिए Task.async/3 देखें।

ध्यान दें कि इस कार्य के लिए कार्य पर्यवेक्षक की आवश्यकता है :temporary रूप से :restart विकल्प (डिफ़ॉल्ट), जैसा कि async_nolink/4 कार्य के लिए एक सीधा संदर्भ रखता है जो कार्य के पुनरारंभ होने पर खो जाता है।

async_stream (पर्यवेक्षक, गणना करने योग्य, मज़ेदार, विकल्प \\ []) (1.4.0 के बाद से)

async_stream(
  Supervisor.supervisor(),
  Enumerable.t(),
  (term() -> term()),
  keyword()
) :: Enumerable.t()

एक स्ट्रीम देता है जो दिए गए फ़ंक्शन को प्रत्येक आइटम पर समवर्ती fun करता fun

enumerable में प्रत्येक आइटम को दिए गए फ़ंक्शन के तर्क के रूप में पारित किया जाता fun और अपने स्वयं के कार्य द्वारा संसाधित किया जाता है। दिए गए supervisor तहत कार्यों को चालू किया जाएगा और वर्तमान प्रक्रिया से जोड़ा जाएगा, इसी तरह async/2

चर्चा, विकल्प और उदाहरण के लिए async_stream/6 देखें।

async_stream (सुपरवाइज़र, एन्युमरेबल, मॉड्यूल, फंक्शन, आर्ग्स, विकल्प \\ []) (1.4.0 के बाद से)

async_stream(
  Supervisor.supervisor(),
  Enumerable.t(),
  module(),
  atom(),
  [term()],
  keyword()
) :: Enumerable.t()

एक स्ट्रीम देता है जो दिए गए module , function चलाता है, और प्रत्येक आइटम पर args समरूपता में enumerable

प्रत्येक आइटम को दिए गए आर्गन्स के लिए तैयार किया जाएगा और अपने स्वयं के कार्य द्वारा संसाधित किया जाएगा। दिए गए supervisor तहत कार्यों को चालू किया जाएगा और वर्तमान प्रक्रिया से जोड़ा जाएगा, इसी तरह async/4

जब स्ट्रीम किया जाता है, तो प्रत्येक कार्य सफल पूर्ण होने पर {:ok, value} उत्सर्जन करेगा या यदि कॉलर बाहर निकल रहा है तो {:exit, reason} । परिणाम मूल enumerable के समान क्रम में उत्सर्जित होते हैं।

समसामयिकता के स्तर को इसके माध्यम से नियंत्रित किया जा सकता है :max_concurrency विकल्प और :max_concurrency System.schedulers_online/0 डिफॉल्ट। किसी कार्य उत्तर के बिना प्रतीक्षा करने के लिए अधिकतम समय का प्रतिनिधित्व करने वाले विकल्प के रूप में एक टाइमआउट भी दिया जा सकता है।

अंत में, यदि आप खुद को async_stream_nolink/6 स्ट्रीम के अंदर से बाहर निकलने के लिए ट्रैपिंग async_stream_nolink/6 पाते हैं, तो async_stream_nolink/6 का उपयोग करके async_stream_nolink/6 कार्यों को शुरू करने पर विचार करें जो वर्तमान प्रक्रिया से जुड़े नहीं हैं।

विकल्प

  • :max_concurrency - एक ही समय में चलाने के लिए अधिकतम कार्य सेट करता है। Defaults to System.schedulers_online/0
  • :ordered - क्या परिणाम उसी क्रम में वापस किए जाने चाहिए जैसे इनपुट स्ट्रीम। यह विकल्प तब उपयोगी होता है जब आपके पास बड़ी धाराएँ हों और वे वितरित होने से पहले परिणामों को बफर नहीं करना चाहते। true अवहेलना।
  • :timeout - एक कार्य का उत्तर प्राप्त करने के लिए (मिलीसेकंड में) प्रतीक्षा करने के लिए अधिकतम समय (सभी चल रहे कार्यों के पार)। 5000 कमी।
  • :on_timeout - जब कोई कार्य समय समाप्त होता है तो क्या करें। संभावित मूल्य हैं:

    • :exit (डिफ़ॉल्ट) - वह प्रक्रिया जिससे कार्य समाप्त होते हैं।
    • :kill_task - जो कार्य समाप्त हो गया है उसे मार दिया गया है। उस कार्य के लिए उत्सर्जित मूल्य {:exit, :timeout}
  • :shutdown - :brutal_kill अगर कार्यों को शटडाउन पर सीधे मार दिया जाना चाहिए या एक पूर्णांक जो समयबाह्य मूल्य को दर्शाता है, तो 5000 मिलीसेकंड तक चूक हो जाती है।

उदाहरण

आइए एक स्ट्रीम बनाएं और फिर इसे एन्यूमरेट करें:

stream = Task.Supervisor.async_stream(MySupervisor, collection, Mod, :expensive_fun, [])
Enum.to_list(stream)

async_stream_nolink (पर्यवेक्षक, गणना करने योग्य, मजेदार, विकल्प \\ []) (1.4.0 के बाद से)

async_stream_nolink(
  Supervisor.supervisor(),
  Enumerable.t(),
  (term() -> term()),
  keyword()
) :: Enumerable.t()

एक स्ट्रीम देता है जो दी गई function को प्रत्येक आइटम पर enumerable समवर्ती रूप से चलाता है।

enumerable में प्रत्येक आइटम को दिए गए फ़ंक्शन के तर्क के रूप में पारित किया जाता fun और अपने स्वयं के कार्य द्वारा संसाधित किया जाता है। दिए गए supervisor तहत कार्यों को जन्म दिया जाएगा और इसे async_nolink/2 समान वर्तमान प्रक्रिया से नहीं जोड़ा जाएगा।

चर्चा और उदाहरण के लिए async_stream/6 देखें।

async_stream_nolink (सुपरवाइजर, एन्युमरेबल, मॉड्यूल, फंक्शन, आर्ग, विकल्प \\ []) (1.4.0 के बाद से)

async_stream_nolink(
  Supervisor.supervisor(),
  Enumerable.t(),
  module(),
  atom(),
  [term()],
  keyword()
) :: Enumerable.t()

एक स्ट्रीम देता है जो दिए गए module , function चलाता है, और प्रत्येक आइटम पर args समरूपता में enumerable

enumerable प्रत्येक आइटम को दिए गए आर्गों के लिए तैयार किया जाएगा और अपने काम से संसाधित किया जाएगा। दिए गए supervisor तहत कार्यों को जन्म दिया जाएगा और वर्तमान प्रक्रिया से लिंक नहीं किया जाएगा, इसी तरह async_nolink/4

चर्चा, विकल्प और उदाहरण के लिए async_stream/6 देखें।

बच्चों (पर्यवेक्षक)

children(Supervisor.supervisor()) :: [pid()]

सभी बच्चों को पीआईडी ​​देता है।

start_child (पर्यवेक्षक, मज़ा, विकल्प \\ [])

start_child(Supervisor.supervisor(), (() -> any()), keyword()) ::
  DynamicSupervisor.on_start_child()

दिए गए supervisor बच्चे के रूप में एक कार्य शुरू करता है।

ध्यान दें कि स्पॉन्ड प्रक्रिया कॉलर से जुड़ी नहीं है, लेकिन केवल पर्यवेक्षक के पास है। यह कार्य उस स्थिति में उपयोगी है, जब कार्य को साइड-इफेक्ट्स (जैसे I / O) करने की आवश्यकता होती है और कॉल करने वाले को वापस रिपोर्ट करने की आवश्यकता नहीं होती है।

विकल्प

  • :restart - पुनः आरंभ की रणनीति, हो सकता है :temporary (डिफ़ॉल्ट) :transient या :permanent :temporary अर्थ है कार्य को कभी भी पुनः आरंभ नहीं किया जाता है :transient मतलब यह है कि यदि पुनरारंभ नहीं होता है तो इसे फिर से शुरू किया जाता है :normal :shutdown या {:shutdown, reason} । A :permanent पुनरारंभ रणनीति का अर्थ है कि यह हमेशा पुनरारंभ होता है। यह चूक करता है :temporary

  • :shutdown - :brutal_kill अगर कार्यों को शटडाउन पर सीधे मार दिया जाना चाहिए या एक पूर्णांक जो समयबाह्य मूल्य को दर्शाता है, तो 5000 मिलीसेकंड तक चूक हो जाती है।

start_child (पर्यवेक्षक, मॉड्यूल, मज़ा, args, विकल्प \\ [])

start_child(Supervisor.supervisor(), module(), atom(), [term()], keyword()) ::
  DynamicSupervisor.on_start_child()

दिए गए supervisor बच्चे के रूप में एक कार्य शुरू करता है।

कार्य को छोड़कर start_child/2 समान, दिए गए module , fun और start_child/2 द्वारा निर्दिष्ट किया गया है।

start_link (विकल्प \\ [])

start_link([option()]) :: Supervisor.on_start()

एक नया पर्यवेक्षक शुरू करता है।

उदाहरण

एक कार्य पर्यवेक्षक को आमतौर पर टुपल प्रारूप का उपयोग करके पर्यवेक्षण वृक्ष के नीचे शुरू किया जाता है:

{Task.Supervisor, name: MyApp.TaskSupervisor}

आप इसे start_link/1 सीधे कॉल करके भी शुरू कर सकते हैं:

Task.Supervisor.start_link(name: MyApp.TaskSupervisor)

लेकिन यह केवल स्क्रिप्टिंग के लिए अनुशंसित है और उत्पादन कोड से बचा जाना चाहिए। सामान्यतया, पर्यवेक्षण पेड़ों के अंदर प्रक्रियाओं को हमेशा शुरू किया जाना चाहिए।

विकल्प

  • :name - पर्यवेक्षक का नाम दर्ज करने के लिए उपयोग किया जाता है, समर्थित मान GenServer मॉड्यूल डॉक्स में Name Registration अनुभाग के तहत वर्णित हैं;

  • :max_restarts :max_seconds और :max_children - जैसा कि :max_children में निर्दिष्ट है;

यह फ़ंक्शन भी प्राप्त कर सकता है :restart और :shutdown विकल्प के रूप में :shutdown लेकिन उन दो विकल्पों को हटा दिया गया है और अब उन्हें सीधे start_child और async को देना पसंद किया जाता है।

terminate_child (पर्यवेक्षक, पीआईडी)

terminate_child(Supervisor.supervisor(), pid()) :: :ok | {:error, :not_found}

दिए गए pid साथ बच्चे को टर्मिनेट करता है।