समय-समय पर संदेश भेजना

एरांग पर एक पोस्ट, लेकिन अन्य सभी भाषाओं पर लागू होती है।

आइए, हम दूसरी बार एक बार कुछ करना चाहते हैं, उदाहरण के लिए, HTTP url के माध्यम से फ़ाइल की उपस्थिति की जांच करना। हमने इसके लिए प्रक्रिया शुरू की, यह आवश्यक है कि वह नियमित रूप से पर्याप्त कुछ करे।

तीन कार्य हैं जो हमें erlang में रुचि रखते हैं: टाइमर: send_interval, टाइमर: send_after, और erlang: send_after।

पहले मैं समझाऊंगा कि send_interval का उपयोग क्यों नहीं किया जा सकता है।



टाइमर: send_interval इसमें समस्या है कि यह बिना जाँच किए संदेश भेजता है यदि पिछले एक को संसाधित किया गया है। नतीजतन, यदि कार्य का निष्पादन छड़ी करना शुरू कर देता है, तो हमारी प्रक्रिया केवल इस कार्य से निपटती है। एक बुरे मामले में, कतार में संदेशों का संचय शुरू होता है, एक स्मृति रिसाव और प्रक्रिया की प्रतिक्रिया का पूर्ण नुकसान।

मैंने बार-बार प्रक्रिया के message_queue में कई सौ चेक संदेश देखे हैं।

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

इसलिए, सही कदम कार्य प्रसंस्करण के अंत में अपने आप को संदेश अग्रेषित करना है।

टाइमर के बीच: send_after और erlang: send_after, पसंद स्पष्ट है: erlang: send_after। टाइमर मॉड्यूल यह काफी गैर-आशावादी रूप से करता है और कई टाइमर समस्याएं पैदा करना शुरू कर देता है।

Erlang का उपयोग नहीं करने का एकमात्र कारण: send_after है जब कई हजारों प्रक्रियाएं हैं और आप सिस्टम को लोड किए बिना संदेशों को समूहित कर सकते हैं जो प्रक्रिया के लिए कठिन हैं, लेकिन यह एक अत्यंत दुर्लभ स्थिति है।

हालाँकि, यहाँ एक गलती करना आसान है:

init([]) -> self() ! check, {ok, state}. handle_info(check, State) -> do_job(State), erlang:send_after(1000, self(), check), {noreply, State}. 

यदि कोई व्यक्ति प्रक्रिया को चेक संदेश भेजता है तो क्या होता है? यह एक दूसरी लहर उत्पन्न करेगा, क्योंकि प्रत्येक चेक संदेश एक गारंटीकृत पुनः टाइमर की ओर जाता है।

नतीजतन, यदि आप 20 संदेश भेजते हैं, तो समय में प्रत्येक क्षण की प्रक्रिया में 20 टाइमर होंगे, जिनमें से संख्या में कमी नहीं होगी।

सही उत्तर है:

 init([]) -> Timer = erlang:send_after(1, self(), check), {ok, Timer}. handle_info(check, OldTimer) -> erlang:cancel_timer(OldTimer), do_task(), Timer = erlang:send_after(1000, self(), check), {noreply, Timer}. 

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