यह जांच रहा है कि मेलबॉक्स खाली है या नहीं? erlang

Question

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

Answer 1

receive टाइमआउट के लिए आपको 0 का उपयोग करने में सक्षम होना चाहिए। नीचे दिए गए उदाहरण में, यह कतार से संदेश प्राप्त करने का प्रयास करेगा, अगर वहां कोई नहीं है तो यह परमाणु false लौटाएगा।

1> receive _ -> true 
1> after 0 -> 
1> false 
1> end. 
empty 

चेतावनी इस होगा संदेश खपत करते हैं।

एक अन्य तरीका erlang:process_info का उपयोग करना होगा, लेकिन यह केवल डीबगिंग के लिए माना जाता है।

6> {message_queue_len, QueueLen} = erlang:process_info(self(), message_queue_len). 
{message_queue_len,0} 
7> QueueLen. 
0 

कुल मिलाकर अब:

16> HasMessages = fun(Pid) ->           
16>  element(2, erlang:process_info(Pid, message_queue_len)) > 0  
16> end. 
#Fun<erl_eval.6.80247286> 
17> HasMessages(self()).                  
false 
18> self() ! test. 
test 
19> HasMessages(self()). 
true 

Answer 2

आंतरिक वहाँ अगर वहाँ प्रक्रिया मेलबॉक्स में संदेश है परीक्षण करने के लिए साधन हैं।

लेकिन सावधान रहें! मुझे नहीं लगता कि Erlang उस तरह इस्तेमाल किया जा करने के लिए है:

{module, hasMsg}. 
{exports, [{module_info,0},{module_info,1},{hasMsg,0},{peekMsg,1},{lastMsg,1}]}. 
{attributes, []}. 
{labels, 17}. 

{function, hasMsg, 0, 2}. 
    {label,1}. 
     {func_info,{atom,hasMsg},{atom,hasMsg},0}. 
    {label,2}. 
     {loop_rec,{f,4},{x,0}}. 
     {move,{atom,true},{x,0}}. 
     return. 
    {label,3}. 
     {loop_rec_end,{f,2}}. 
    {label,4}. 
     timeout. 
     {move,{atom,false},{x,0}}. 
     return. 

{function, peekMsg, 1, 6}. 
    {label,5}. 
     {func_info,{atom,hasMsg},{atom,peekMsg},1}. 
    {label,6}. 
     {loop_rec,{f,8},{x,0}}. 
     return. 
    {label,7}. 
     {loop_rec_end,{f,6}}. 
    {label,8}. 
     timeout. 
     return. 

{function, lastMsg, 1, 10}. 
    {label,9}. 
     {func_info,{atom,hasMsg},{atom,lastMsg},1}. 
    {label,10}. 
     {loop_rec,{f,12},{x,0}}. 
     {test,is_eq_exact,{f,11},[]}. 
    {label,11}. 
     {loop_rec_end,{f,10}}. 
    {label,12}. 
     timeout. 
     return. 

{function, module_info, 0, 14}. 
    {label,13}. 
     {func_info,{atom,hasMsg},{atom,module_info},0}. 
    {label,14}. 
     {move,{atom,hasMsg},{x,0}}. 
     {call_ext_only,1,{extfunc,erlang,get_module_info,1}}. 

{function, module_info, 1, 16}. 
    {label,15}. 
     {func_info,{atom,hasMsg},{atom,module_info},1}. 
    {label,16}. 
     {move,{x,0},{x,1}}. 
     {move,{atom,hasMsg},{x,0}}. 
     {call_ext_only,2,{extfunc,erlang,get_module_info,2}}. 

संकलित: erlc +from_asm hasMsg.S।

मॉड्यूल hasMsg शामिल हैं:

• hasMsg/0 एक बूलियन मेलबॉक्स में संदेशों देखते हैं कि क्या देता है।
• peekMsg/1 इसे हटाने के बिना सबसे पुराना संदेश लौटाता है। मेलबॉक्स खाली है, तो इसकी तर्क देता है।
• lastMsg/1 इसे हटाने के बिना नवीनतम संदेश देता है। मेलबॉक्स खाली है, तो इसकी तर्क देता है।

Answer 3

आप संदेश कतार सहित प्रक्रिया जानकारी तक पहुंचने के लिए process_info/2 बीआईएफ का उपयोग कर सकते हैं। तो

process_info(self(), message_queue_len) => {message_queue_len,Length} 

और

process_info(self(), messages) => {messages,MessageList} 

दूसरा एक अगर वहाँ कतार में कई संदेश हैं के रूप में सूची प्रत्येक कॉल के लिए बनाई गई है अक्षम है (हालांकि नहीं निश्चित रूप से संदेश)। एक प्रक्रिया के बारे में आप कई दिलचस्प चीजें पा सकते हैं। इस पर कोई प्रतिबंध नहीं है कि आप किस प्रक्रिया को जानकारी प्राप्त कर सकते हैं, आप इसे किसी भी प्रक्रिया के लिए कर सकते हैं।