उपज के मुख्य उपयोग क्या हैं (), और यह जुड़ने () और व्यवधान () से कैसे भिन्न है?

Question

मैं yield()जावा में विधि के उपयोग के बारे में थोड़ा भ्रमित हूं , विशेष रूप से नीचे दिए गए उदाहरण कोड में। मैंने यह भी पढ़ा है कि पैदावार () एक धागे के निष्पादन को रोकने के लिए उपयोग किया जाता है।

मेरे प्रश्न हैं:

1. मेरा मानना ​​है कि नीचे दिए गए कोड का उपयोग करते समय एक ही आउटपुट में परिणाम होता है yield()और जब उपयोग नहीं होता है। क्या ये सही है?

2. वास्तव में, मुख्य उपयोग क्या हैं yield()?

3. किन तरीकों और तरीकों yield()से अलग है ?join()interrupt()

कोड उदाहरण:

public class MyRunnable implements Runnable {

   public static void main(String[] args) {
      Thread t = new Thread(new MyRunnable());
      t.start();

      for(int i=0; i<5; i++) {
          System.out.println("Inside main");
      }
   }

   public void run() {
      for(int i=0; i<5; i++) {
          System.out.println("Inside run");
          Thread.yield();
      }
   }
}

मैं समान आउटपुट का उपयोग कोड के साथ और बिना उपयोग किए करता हूं yield():

Inside main
Inside main
Inside main
Inside main
Inside main
Inside run
Inside run
Inside run
Inside run
Inside run

Comments

बहुत अधिक व्यापक होने के लिए इस qustion को बंद किया जाना चाहिए ।

— राडवल्ड

नहीं, यह उसी परिणाम को नहीं लौटाता जब आपके पास है yield()और नहीं। जब आपके पास 5 के बजाय बड़ा i होता है, तो आप yield()विधि का प्रभाव देख सकते हैं ।

— लक्ष्मण

Answer 1

स्रोत: http://www.javamex.com/tutorials/threads/yield.shtml

खिड़कियाँ

हॉटस्पॉट कार्यान्वयन में, Thread.yield()जावा 5 और जावा 6 के बीच काम करने का तरीका बदल गया है।

जावा 5 में, Thread.yield()विंडोज एपीआई कॉल कहते हैं Sleep(0)। यह वर्तमान धागे की मात्रा को साफ करने और कतार के अंत में अपने प्राथमिकता स्तर के लिए डालने का विशेष प्रभाव है । दूसरे शब्दों में, एक ही प्राथमिकता के सभी चलने योग्य धागे (और अधिक प्राथमिकता वाले) उपज वाले धागे को अगली बार दिए गए सीपीयू समय से पहले चलाने का मौका मिलेगा। जब इसे फिर से निर्धारित किया जाता है, तो यह एक पूर्ण पूर्ण मात्रा के साथ वापस आ जाएगा , लेकिन उपज के समय से शेष मात्रा में से किसी को "ले" नहीं करता है। यह व्यवहार एक गैर-शून्य नींद से थोड़ा अलग है जहां नींद का धागा आम तौर पर 1 क्वांटम मान खो देता है (प्रभाव में, 10 में से 1/3 या 15 मी टिक)।

जावा 6 में, इस व्यवहार को बदल दिया गया था। Hotspot VM अब Thread.yield()Windows SwitchToThread()API कॉल का उपयोग करता है । यह कॉल वर्तमान थ्रेड को उसकी वर्तमान समय सीमा देता है , लेकिन इसकी संपूर्ण मात्रा को नहीं। इसका मतलब यह है कि अन्य थ्रेड्स की प्राथमिकताओं के आधार पर, उपज के धागे को बाद में एक बाधा अवधि में वापस निर्धारित किया जा सकता है । ( समय पर अधिक जानकारी के लिए थ्रेड शेड्यूलिंग पर अनुभाग देखें ।)

लिनक्स

लिनक्स के तहत, हॉटस्पॉट बस कॉल करता है sched_yield()। इस कॉल के परिणाम थोड़े अलग हैं, और संभवतः विंडोज के तहत अधिक गंभीर हैं:

• एक उपज वाले धागे को सीपीयू का एक और टुकड़ा नहीं मिलेगा जब तक कि अन्य सभी धागे सीपीयू का एक टुकड़ा न हो ;
• (कम से कम कर्नेल २.६. on बाद में), यह तथ्य कि धागे की पैदावार का हाल ही में इसके हालिया सीपीयू आवंटन पर शेड्यूलर के उत्तराधिकारियों द्वारा ध्यान में रखा गया है - इस प्रकार, संक्षेप में, एक धागा जो उपज है वह अधिक सीपीयू में अनुसूचित हो सकता है। भविष्य।

( प्राथमिकता और शेड्यूलिंग एल्गोरिदम पर अधिक विवरण के लिए थ्रेड शेड्यूलिंग पर अनुभाग देखें ।)

कब करें इस्तेमाल yield()?

मैं कहूंगा कि व्यावहारिक रूप से कभी नहीं । इसका व्यवहार मानक रूप से परिभाषित नहीं है और आम तौर पर उन कार्यों को करने के लिए बेहतर तरीके हैं जो आप उपज के साथ प्रदर्शन करना चाहते हैं ():

• यदि आप सीपीयू के केवल एक हिस्से का उपयोग करने की कोशिश कर रहे हैं , तो आप यह अनुमान लगाने के लिए कि सीपीयू थ्रेड ने प्रसंस्करण के अंतिम समय में कितना सीपीयू का उपयोग करके अधिक नियंत्रणीय तरीके से कर सकते हैं, फिर क्षतिपूर्ति करने के लिए कुछ समय के लिए सो रहे हैं: देखें नींद () विधि;
• यदि आप किसी प्रक्रिया या संसाधन के पूरा होने या उपलब्ध होने की प्रतीक्षा कर रहे हैं, तो इसे पूरा करने के लिए और अधिक कुशल तरीके हैं, जैसे कि एक धागे के पूरा होने का इंतजार करने के लिए जुड़ने () का उपयोग करके, एक धागे की अनुमति देने के लिए प्रतीक्षा / सूचना तंत्र का उपयोग करके दूसरे को संकेत देना कि कोई कार्य पूरा हुआ है, या आदर्श रूप से जावा 5 संगणक में से एक का उपयोग करके एक सेमाफोर या अवरुद्ध प्रतिमा का निर्माण होता है ।

Comments

"शेष क्वांटम", "संपूर्ण क्वांटम" - कहीं न कहीं जिस तरह से कोई भूल गया कि "क्वांटम" शब्द का अर्थ क्या है

— kbolino

@kbolino क्वांटम नया परमाणु है।

— एवगेनी सर्गेव

@kbolino - ... लैटिन: "जितना", "कितना" । मैं यह नहीं देखता कि ऊपर दिए गए उपयोग के साथ यह किसी भी तरह से विरोधाभासी कैसे है। इस शब्द का सीधा मतलब है किसी वस्तु का एक निश्चित मात्रा में होना, इसलिए इसका इस्तेमाल और शेष हिस्सों में विभाजित करना मुझे पूरी तरह से उचित लगता है।

— पेरीटाटा ब्रीटाटा

@PeriataBreatta मुझे लगता है कि यह अधिक समझ में आता है अगर आप भौतिकी के बाहर के शब्द से परिचित हैं। भौतिकी की परिभाषा केवल वही थी जिसे मैं जानता था।

— kbolino

मैंने 7, 8, 9 के लिए इस उत्तर को अपडेट करने के लिए इस सवाल पर एक इनाम रखा। इसे 7,8 और 8 के बारे में वर्तमान जानकारी के साथ संपादित करें और आपको इनाम मिलेगा।

Answer 2

मैं देख रहा हूं कि इस प्रश्न का उत्तर एक सक्रियता के साथ दिया गया है, अब यह पूछना कि इसके व्यावहारिक उपयोग क्या yieldहैं। मैं अपने अनुभव से एक उदाहरण दूंगा।

जैसा कि हम जानते हैं, yieldकॉलिंग थ्रेड को प्रोसेसर को छोड़ने के लिए मजबूर करता है जो कि इस पर चल रहा है ताकि दूसरे थ्रेड को चलाने के लिए शेड्यूल किया जा सके। यह तब उपयोगी होता है जब वर्तमान थ्रेड ने अपना काम अभी के लिए समाप्त कर दिया है, लेकिन जल्दी से कतार के सामने लौटना चाहता है और जांचना चाहता है कि क्या कुछ स्थिति बदल गई है। यह एक स्थिति चर से कैसे अलग है? yieldरनिंग स्थिति में बहुत जल्दी लौटने के लिए थ्रेड को सक्षम करता है। जब एक कंडीशन वैरिएबल पर थ्रेड को सस्पेंड किया जाता है और सिग्नल को अलग थ्रेड के लिए प्रतीक्षा करने की आवश्यकता होती है, तो उसे जारी रखना चाहिए।yieldमूल रूप से कहते हैं "एक अलग धागे को चलाने की अनुमति दें, लेकिन मुझे बहुत जल्द काम करने की अनुमति दें क्योंकि मुझे उम्मीद है कि मेरे राज्य में बहुत जल्दी कुछ बदलने की उम्मीद है"। यह व्यस्त कताई की ओर संकेत करता है, जहां एक स्थिति तेजी से बदल सकती है लेकिन धागे को निलंबित करने से एक बड़ा प्रदर्शन प्रभावित होगा।

लेकिन पर्याप्त बड़बड़ा, यहां एक ठोस उदाहरण है: वेवफ्रंट समानांतर पैटर्न। इस समस्या का एक मूल उदाहरण 1s के व्यक्तिगत "द्वीपों" को 0s और 1s से भरे हुए एक द्वि-आयामी सरणी में गणना कर रहा है। एक "द्वीप" उन कोशिकाओं का एक समूह है जो प्रत्येक या तो लंबवत या क्षैतिज रूप से आसन्न होते हैं:

1 0 0 0
1 1 0 0
0 0 0 1
0 0 1 1
0 0 1 1

यहां हमारे पास 1s के दो द्वीप हैं: शीर्ष-बाएं और नीचे-दाएं।

एक सरल उपाय यह है कि पूरे एरे पर पहला पास बनाया जाए और 1 मानों को एक वृद्धिशील काउंटर से बदला जाए, जैसे कि अंत में प्रत्येक 1 को पंक्ति क्रम में इसके क्रम संख्या के साथ बदल दिया गया:

1 0 0 0
2 3 0 0
0 0 0 4
0 0 5 6
0 0 7 8

अगले चरण में, प्रत्येक मूल्य को अपने और अपने पड़ोसियों के मूल्यों के बीच न्यूनतम से बदल दिया जाता है:

1 0 0 0
1 1 0 0
0 0 0 4
0 0 4 4
0 0 4 4

अब हम आसानी से यह निर्धारित कर सकते हैं कि हमारे पास दो द्वीप हैं।

जिस हिस्से को हम समानांतर में चलाना चाहते हैं, वह वह कदम है, जहां हम न्यूनतम गणना करते हैं। बहुत अधिक विस्तार में जाने के बिना, प्रत्येक थ्रेड एक पंक्तिबद्ध तरीके से पंक्तियों को प्राप्त करता है और ऊपर की पंक्ति को संसाधित करने वाले थ्रेड द्वारा गणना मूल्यों पर निर्भर करता है। इस प्रकार, प्रत्येक धागे को पिछली पंक्ति को संसाधित करने वाले थ्रेड के पीछे थोड़ा अंतराल करने की आवश्यकता होती है, लेकिन उचित समय के भीतर भी रखना चाहिए। अधिक विवरण और एक कार्यान्वयन इस दस्तावेज़ में स्वयं द्वारा प्रस्तुत किए गए हैं । ध्यान दें कि sleep(0)C के बराबर कौन सा उपयोग कम या ज्यादा है yield।

इस मामले yieldमें प्रत्येक धागे को थामने के लिए मजबूर करने के लिए इस्तेमाल किया गया था, लेकिन चूंकि धागा प्रसंस्करण आसन्न पंक्ति बहुत जल्दी इस बीच में आगे बढ़ेगा, एक शर्त चर एक विनाशकारी विकल्प साबित होगा।

जैसा कि आप देख सकते हैं, yieldकाफी बढ़िया अनाज अनुकूलन है। गलत जगह पर इसका उपयोग करना, उदाहरण के लिए शायद ही कभी बदलने वाली स्थिति का इंतजार करना, सीपीयू के अत्यधिक उपयोग का कारण होगा।

लंबे प्रलाप के लिए क्षमा करें, आशा है कि मैंने खुद को स्पष्ट कर दिया है।

Comments

IIUC जो आप दस्तावेज़ में प्रस्तुत करते हैं, विचार यह है कि इस मामले में, यह व्यस्त-प्रतीक्षा करने के लिए अधिक कुशल है, यह कहते yieldहुए कि जब स्थिति अन्य थ्रेड्स को संगणना के साथ आगे बढ़ने का मौका देने के लिए संतुष्ट नहीं है, बजाय अधिक उच्च उपयोग के स्तर तुल्यकालन आदिम, सही?

— पेट्र पुडलक

@Petr पुडलक: हाँ। मैंने इसे थ्रेडिंग सिग्नलिंग का उपयोग करके बेंचमार्क किया और इस मामले में प्रदर्शन अंतर बहुत बड़ा था। चूंकि स्थिति बहुत जल्दी सच हो सकती है (यह प्रमुख मुद्दा है), हालत चर बहुत धीमी है क्योंकि ओएस द्वारा थ्रेड पर रखा जाता है, बजाय सीपीयू को उपयोग करने के बहुत कम समय के लिए छोड़ दिया जाता है yield।

— ट्यूडर

@ महान व्याख्या!

— डेवलपर Marius ėilėnas

"नींद के उपयोग पर ध्यान दें (0) जो कम या ज्यादा सी के बराबर उपज है।" .. ठीक है, अगर आप जावा के साथ सोना (0) चाहते हैं, तो आप इसका उपयोग क्यों नहीं करेंगे? Thread.sleep () एक ऐसी चीज़ है जो पहले से मौजूद है। मुझे यकीन नहीं है कि यदि यह उत्तर तर्क देता है कि थ्रेड के बजाय थ्रेड.लाइड () का उपयोग क्यों किया जाएगा (0); एक मौजूदा धागा भी है जो समझाता है कि वे अलग क्यों हैं।

— eis

@eis: Thread.sleep (0) vs Thread.yield () इस उत्तर के दायरे से परे है। मैं केवल C. में एक करीबी समकक्ष की तलाश कर रहे लोगों के लिए Thread.sleep (0) का उल्लेख कर रहा था। प्रश्न Thread.yield () के उपयोगों के बारे में था।

— ट्यूडर

Answer 3

केवल जावा में yield(), interrupt()और join()- सामान्य रूप से, के बीच के अंतर के बारे में

1. उपज : वस्तुतः, 'उपज' का अर्थ है, जाने देना, त्याग देना, समर्पण करना। एक उपज धागा ऑपरेटिंग सिस्टम (या वर्चुअल मशीन, या क्या नहीं) को बताता है कि वह अन्य थ्रेड्स को अपने स्थान पर शेड्यूल करने के लिए तैयार है। यह इंगित करता है कि यह बहुत महत्वपूर्ण कुछ नहीं कर रहा है। यह केवल एक संकेत है, हालांकि, और किसी भी प्रभाव के लिए गारंटी नहीं है।
2. ज्वाइनिंग : जब कई थ्रेड्स किसी हैंडल, या टोकन, या एंटिटी पर 'जॉइन' करते हैं, तो सभी तब तक प्रतीक्षा करते हैं जब तक कि अन्य सभी प्रासंगिक थ्रेड्स का निष्पादन पूरा नहीं हो जाता (पूरी तरह से या अपने संबंधित जॉइन्ट तक)। इसका मतलब है कि धागे का एक गुच्छा सभी ने अपने कार्यों को पूरा कर लिया है। फिर इन थ्रेड्स में से प्रत्येक को अन्य काम जारी रखने के लिए निर्धारित किया जा सकता है, उन सभी कार्यों को पूरा करने में सक्षम होने के नाते। (एसक्यूएल जॉइन के साथ भ्रमित होने की नहीं!)
3. रुकावट : एक धागे का इस्तेमाल एक अन्य धागे को 'पोक' करने के लिए किया जाता है जो सो रहा है, या प्रतीक्षा कर रहा है, या जुड़ रहा है - ताकि इसे फिर से जारी रखने का समय निर्धारित हो, शायद एक संकेत के साथ यह बाधित हो गया है। (हार्डवेयर में रुकावट न हो!)

जावा के लिए, विशेष रूप से देखें

1. में शामिल होना:

   Thread.join का उपयोग कैसे करें? (यहाँ StackOverflow पर)

   धागे से कब जुड़ना है?

2. उपज:

3. दखल:

   क्या Thread.interrupt () बुराई है? (यहाँ StackOverflow पर)

Comments

हैंडल या टोकन से जुड़ने का क्या मतलब है? प्रतीक्षा () और सूचित () विधियाँ ऑब्जेक्ट पर हैं, जिससे उपयोगकर्ता किसी भी मनमानी वस्तु पर प्रतीक्षा कर सकता है। लेकिन ज्वाइन () कम अमूर्त लगता है और आपको जिस विशिष्ट थ्रेड को जारी रखने से पहले पूरा करना चाहते हैं, उस पर कॉल करने की आवश्यकता है ... है ना?

— स्पाकार्की 21

@ Spaaarky21: मेरा मतलब आम तौर पर जावा में नहीं है। इसके अलावा, एक wait()शामिल नहीं है, यह उस वस्तु पर ताला है जिसके बारे में कॉलिंग थ्रेड अधिग्रहित करने का प्रयास कर रहा है - यह तब तक इंतजार करता है जब तक कि लॉक को दूसरों द्वारा मुक्त नहीं किया जाता है और थ्रेड द्वारा अधिग्रहित किया जाता है। तदनुसार मेरे उत्तर को टाल दिया।

— einpoklum

Answer 4

सबसे पहले, वास्तविक विवरण है

वर्तमान में निष्पादित ऑब्जेक्ट को अस्थायी रूप से रोकने के लिए और अन्य थ्रेड्स को निष्पादित करने की अनुमति देता है।

अब, यह बहुत संभव है कि आपका मुख्य धागा लूप को पांच बार निष्पादित करेगा, इससे पहले कि runनए धागे की विधि निष्पादित की जा रही है, इसलिए सभी कॉल करने के yieldलिए मुख्य धागे में लूप निष्पादित होने के बाद ही होगा।

joinवर्तमान थ्रेड को तब तक रोक देगा जब तक कि थ्रेड को join()निष्पादित नहीं किया जाता है।

interruptउस थ्रेड को बाधित करेगा जो उस पर कॉल किया जा रहा है, जिससे InterruptedException पैदा होगी ।

yield अन्य थ्रेड्स के लिए एक संदर्भ स्विच की अनुमति देता है, इसलिए यह थ्रेड प्रक्रिया के संपूर्ण CPU उपयोग का उपभोग नहीं करेगा।

Comments

+1। यह भी ध्यान रखें कि कॉलिंग यील्ड () के बाद भी, कोई गारंटी नहीं है कि समान थ्रेड को निष्पादन के लिए फिर से नहीं चुना जाएगा, समान प्राथमिकता वाले थ्रेड्स का एक पूल दिया गया है।

— एंड्रयू फील्डन Andrew

हालाँकि, SwitchToThread()कॉल स्लीप (0) से बेहतर है और यह जावा में बग होना चाहिए :)

— Пет isр Петров

Answer 5

वर्तमान उत्तर पुराने हैं और हाल के परिवर्तनों को देखते हुए संशोधन की आवश्यकता है।

6 से 9 के बाद से जावा संस्करणों के बीच कोई व्यावहारिक अंतर नहीं है Thread.yield()।

टी एल; डॉ;

OpenJDK स्रोत कोड ( http://hg.openjdk.java.net/ ) पर आधारित निष्कर्ष ।

यदि यूएसटीटी जांच के हॉटस्पॉट समर्थन (सिस्टम ट्रेसिंग जानकारी dtrace गाइड में वर्णित है ) और जेवीएम संपत्ति का ध्यान नहीं रखा जाता है, ConvertYieldToSleepतो स्रोत कोड yield()लगभग समान है। नीचे देखें स्पष्टीकरण

जावा 9 :

Thread.yield()OS- विशिष्ट विधि os::naked_yield():
लिनक्स पर कॉल करता है :

void os::naked_yield() {
    sched_yield();
}

विंडोज पर:

void os::naked_yield() {
    SwitchToThread();
}

जावा 8 और पूर्व:

Thread.yield()OS- विशिष्ट विधि os::yield():
लिनक्स पर कॉल करता है :

void os::yield() {
    sched_yield();
}

विंडोज पर:

void os::yield() {  os::NakedYield(); }

जैसा कि आप देख सकते हैं, Thread.yeald()लिनक्स पर सभी जावा संस्करणों के लिए समान है।
आइए देखें विंडोज का os::NakedYield()JDK 8 से:

os::YieldResult os::NakedYield() {
    // Use either SwitchToThread() or Sleep(0)
    // Consider passing back the return value from SwitchToThread().
    if (os::Kernel32Dll::SwitchToThreadAvailable()) {
        return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
    } else {
        Sleep(0);
    }
    return os::YIELD_UNKNOWN ;
}

Win32 एपीआई की SwitchToThread()विधि के अस्तित्व की अतिरिक्त जांच में जावा 9 और जावा 8 के बीच का अंतर । जावा 6 के लिए समान कोड मौजूद
है os::NakedYield()। JDK 7 में स्रोत कोड थोड़ा अलग है लेकिन इसका व्यवहार समान है:

    os::YieldResult os::NakedYield() {
    // Use either SwitchToThread() or Sleep(0)
    // Consider passing back the return value from SwitchToThread().
    // We use GetProcAddress() as ancient Win9X versions of windows doen't support SwitchToThread.
    // In that case we revert to Sleep(0).
    static volatile STTSignature stt = (STTSignature) 1 ;

    if (stt == ((STTSignature) 1)) {
        stt = (STTSignature) ::GetProcAddress (LoadLibrary ("Kernel32.dll"), "SwitchToThread") ;
        // It's OK if threads race during initialization as the operation above is idempotent.
    }
    if (stt != NULL) {
        return (*stt)() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
    } else {
        Sleep (0) ;
    }
    return os::YIELD_UNKNOWN ;
}

SwitchToThread()Windows XP और Windows Server 2003 ( msdn नोट्स देखें ) के बाद से विधि के कारण अतिरिक्त चेक उपलब्ध हैं ।

Answer 6

वास्तव में, उपज के मुख्य उपयोग () क्या हैं?

यील्ड सीपीयू को सुझाव देता है कि आप वर्तमान थ्रेड को रोक सकते हैं और उच्च प्राथमिकता के साथ थ्रेड निष्पादित करना शुरू कर सकते हैं। दूसरे शब्दों में, अधिक महत्वपूर्ण थ्रेड्स के लिए कमरे को छोड़ने के लिए वर्तमान थ्रेड के लिए कम प्राथमिकता मूल्य निर्दिष्ट करना।

मेरा मानना ​​है कि पैदावार () का उपयोग करते समय और इसके उपयोग न करने पर समान आउटपुट में परिणाम के नीचे दिए गए कोड। क्या ये सही है?

नहीं, दोनों अलग-अलग परिणाम देंगे। बिना पैदावार () के, एक बार जब धागा नियंत्रित हो जाता है तो यह एक बार में 'इनसाइड रन' लूप निष्पादित करेगा। हालाँकि, पैदावार () के साथ, एक बार धागा नियंत्रित हो जाने के बाद यह एक बार 'इनसाइड रन' को प्रिंट कर लेगा और फिर किसी भी अन्य धागे को नियंत्रण सौंप देगा। यदि कोई धागा लंबित नहीं है, तो यह धागा फिर से शुरू किया जाएगा। इसलिए हर बार "इनसाइड रन" निष्पादित होने पर यह निष्पादित करने के लिए अन्य थ्रेड्स के लिए दिखेगा और यदि कोई थ्रेड उपलब्ध नहीं है, तो वर्तमान थ्रेड निष्पादित होता रहेगा।

उपज किन तरीकों से उपज () में शामिल होने () और व्यवधान () विधियों से अलग है?

यील्ड () अन्य महत्वपूर्ण थ्रेड्स के लिए जगह देने के लिए है, ज्वाइन () अपने निष्पादन को पूरा करने के लिए किसी अन्य थ्रेड के लिए प्रतीक्षा कर रहा है, और इंटरप्ट () वर्तमान में कुछ और करने के लिए निष्पादित थ्रेड को बाधित करने के लिए है।

Comments

यदि यह कथन सही है, तो पुष्टि करना चाहते हैं Without a yield(), once the thread gets control it will execute the 'Inside run' loop in one go? कृपया स्पष्ट करें।

— अब्दुल्ला खान

Answer 7

Thread.yield()थ्रेड "रनिंग" स्थिति से "रननेबल" स्थिति में जाने का कारण बनता है। नोट: यह "प्रतीक्षा" स्थिति पर जाने के लिए थ्रेड का कारण नहीं है।

Comments

@PJMeisch, उदाहरणों के RUNNINGलिए कोई राज्य नहीं है java.lang.Thread। लेकिन यह देशी धागे के लिए एक देशी "चल" स्थिति को नहीं रोकता है जिसके लिए एक Threadउदाहरण एक प्रॉक्सी है।

— सोलोमन स्लो

Answer 8

Thread.yield ()

जब हम Thread.yield () विधि को लागू करते हैं, तो थ्रेड शेड्यूलर वर्तमान में रननेबल स्थिति में थ्रेड को चालू रखता है और समान प्राथमिकता या उच्च प्राथमिकता का दूसरा थ्रेड चुनता है। यदि कोई समान और उच्च प्राथमिकता वाला धागा नहीं है, तो यह कॉलिंग यील्ड () थ्रेड को पुनर्निर्धारित करता है। याद रखें कि उपज विधि प्रतीक्षा या अवरुद्ध स्थिति में जाने के लिए धागा नहीं बनाती है। यह केवल रनिंग स्टेट से रननेबल स्टेट तक एक थ्रेड बना सकता है।

में शामिल होने के ()

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

Answer 9

उपज () मुख्य उपयोग बहु-थ्रेडिंग एप्लिकेशन को होल्ड पर रखने के लिए है।

इन सभी तरीकों के अंतर उपज हैं () दूसरे धागे को निष्पादित करते समय धागे को पकड़ कर रखता है और उस धागे के पूरा होने के बाद वापस लौटता है, सम्मिलित हों () धागे की शुरुआत को एक साथ निष्पादित करेगा जब तक कि अंत और दूसरे धागे को उस धागे के बाद चलाने के लिए समाप्त, रुकावट () ​​थोड़ी देर के लिए थ्रेड का निष्पादन रोक देगा।

Comments

आपके उत्तर के लिए धन्यवाद। हालांकि यह सिर्फ वही दोहराता है जो अन्य उत्तर पहले से ही विस्तार से बताते हैं। मैं उचित उपयोग-मामलों के लिए बाउंटी की पेशकश कर रहा हूं जहां yieldइसका उपयोग किया जाना चाहिए।

— पेट्र पुडलक