थ्रेड.इल्ड() हानिकारक माना जाता है?

Question

मेरे जावा एप्लिकेशन पर काम करते समय, मेरे पास एक साधारण मल्टीथ्रेडिंग केस (एक एसिंक्रोनस संसाधन लोडर थ्रेड और लोडर को समाप्त करने के लिए एक मुख्य धागा इंतजार करना, यूआई को प्रगति के साथ अपडेट करना) है, जिसे मैंने

पर कॉल करके हल करने के लिए लगाया मुख्य थ्रेड में

while(!foo.isInitialized()) { 
    Thread.yield(); 
} 

। मुझे पता है कि अधिक मजबूत समाधान हैं; फिर भी, लोडर मेरे द्वारा डिज़ाइन नहीं किया गया है और यह मूल रूप से केवल पढ़ने योग्य लाइब्रेरी है (मैं केवल wait() नहीं कर सकता, क्योंकि मैं इसे notify() नहीं भेज सकता; यह भी खत्म होने के बाद मर नहीं जाता है), और मैं बस लोड होने तक प्रतीक्षा करने की आवश्यकता है।

Java doc का कहना है कि (ध्यान दें कि यह 1.6 डॉक्स में not present था और 1.7 डॉक्स से जोड़ा गया है)

यह शायद ही कभी इस विधि का उपयोग करने के लिए उपयुक्त है।

NetBeans मुझे चेतावनी दी है कि java.lang.Thread पर विधि yield() की

प्रार्थना आमतौर पर तुल्यकालन समस्याओं छद्मवेष लिए किया जाता है और बचा जाना चाहिए।

Google Codepro AnalytiX, OTOH, कहते हैं

विधि Thread.yield() क्योंकि उसके व्यवहार सभी प्लेटफ़ॉर्म पर संगत नहीं है नहीं किया जाना चाहिए।

मैं उन चेतावनी के साथ संबंध होना चाहिए और एक बेहतर समाधान खोजने की कोशिश (सभी सुझावों का स्वागत करते हैं कर रहे हैं), या मैं "के रूप में चेतावनी शोर" उन पर विचार करने और दबाने चाहिए/उन्हें अनदेखा?

नोट: मैंने sleep() (Are Thread.sleep(0) and Thread.yield() statements equivalent? का उपयोग करने की स्पष्ट संभावना के बारे में सोचा है) यहां उल्लेख करने लायक है); फिर भी, अगर yield आईएनजी में लगातार सोते समय कोई "बोनस" नहीं है, तो जावा इसे बिल्कुल क्यों प्रदान करता है - और इसके लिए वास्तविक वैध उपयोग के मामले क्या हैं?

थोड़ा संबंधित: Is there a better solution to Thread.yield()? & Thread.Sleep or Thread.Yield

Answer 1

किसी भी इंतजार यांत्रिकी के बिना एक समय पाश में Thread.yield() बुला के साथ मुख्य समस्या यह है कि यह आसानी से अपने कोर में से एक का 100% उपयोग व्यस्त-प्रतीक्षा पाश हो जाता है।

यदि आप उपज करते समय शेड्यूल करने के लिए कोई अन्य धागे नहीं हैं, तो उपजित धागा शायद बहुत जल्दी से फिर से निर्धारित किया जाएगा और इसके परिणामस्वरूप उच्च CPU उपयोग होता है।

इसके अलावा, इस मामले में, मैं नहीं देख सकता कि इससे इससे अधिक हानिकारक होगा। हालांकि, यह बहुत व्यर्थ है - यदि आप व्यस्त-प्रतीक्षा लूप लिखने जा रहे हैं तो आप केवल while (!foo.isInitialized()); कर सकते हैं और शेड्यूलर पर जोर देने से बच सकते हैं।

यदि आपको कोई सूचना नहीं मिलती है, तो आपको क्या करना चाहिए, कम से कम लूप में सोना है। यह आपके CPUs को थोड़ा आराम करने की अनुमति देगा।इस तरह के एक पाश की

विशिष्ट कार्यान्वयन:

while(!foo.isInitialized()) { 
    try { 
     Thread.sleep(20); 
    } catch (InterruptedException e) { 
     Thread.currentThread().interrupt(); 
     return; // or handle some other way 
    } 
}