थ्रेड चलने योग्य स्थिति में चलने से कैसे चलता है?

Question

मैं जानना चाहता हूं कि चलने योग्य और चलने वाले राज्यों के बीच एक थ्रेड आगे और आगे कैसे चलता है। दृश्यों के पीछे वास्तव में क्या होता है। मुझे लगता है कि थ्रेडपूल के मामले में इसकी आवश्यकता होगी लेकिन मैं पूरी तरह से समझने में सक्षम नहीं हूं। कृपया मदद करें मुझे यह समझने के लिए।

Answer 1

अगर धागा राज्य का मतलब है कि अपने को क्रियान्वित रन() विधि और जब runnable विधि में अपनी चल रहा है इसकी निष्पादन शुरूआत() विधि .... तो मुझे लगता है कि रननेबल से चलने से चलने का मतलब है कि यह रन() से शुरू करने के लिए वापस जा रहा है()

अधिकांश ऑपरेटिंग सिस्टमों के नामकरण में, "चलने" का अर्थ है कि थ्रेड वास्तव में कुछ CPU पर निर्देशों को निष्पादित कर रहा है, और "रननेबल" का अर्थ है कि किसी भी CPU को चलाने के लिए थ्रेड को "चलने" से रोकता है।

एक जावा प्रोग्राम उन दो राज्यों के बीच अंतर नहीं बता सकता है। धागा बताता है कि जावा के बारे में पता है कि नया, अनावश्यक, अवरुद्ध, प्रतीक्षा, TIMED_WAITING, और समाप्त हो गया है।

t.start() से पहले एक धागा नया है, और यह कभी भी बाद में वापस नहीं जा सकता है। प्रतीक्षा और TIMED_WAITING दोनों का मतलब है कि धागा किसी अन्य धागे में notify() कॉल के लिए प्रतीक्षा कर रहा है। ब्लॉक्ड का मतलब है कि यह किसी और चीज की प्रतीक्षा कर रहा है (उदाहरण के लिए, synchronized ब्लॉक दर्ज करने के लिए), और टर्मिनट का मतलब है कि यह समाप्त हो गया है।

Answer 2

Yield एक स्थिर विधि है जो वर्तमान में निष्पादित थ्रेड को थ्रेड पूल में समान प्राथमिकता वाले धागे का मौका देने के लिए कहती है।

कोई गारंटी नहीं है कि Yield वर्तमान में निष्पादन योग्य थ्रेड को तुरंत चलने योग्य राज्य में कर देगा। एक महत्वपूर्ण बिंदु याद रखें कि उपज विधि थ्रेड को प्रतीक्षा या अवरुद्ध स्थिति में नहीं जाने देती है। यह केवल रनिंग स्टेट से रननेबल स्टेट तक धागा बना सकता है। एक प्रोग्रामर की मार्गदर्शिका का

Answer 3

निकालें जावा SCJP प्रमाणन के लिए: धागे:

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

स्थैतिक शून्य नींद (लंबी मिलीसेक) इंटरप्टेड एक्सेप्शन फेंकता है वर्तमान धागा निर्दिष्ट समय के लिए फिर से चलाने के लिए योग्य होने से पहले सो जाता है।

अंतिम शून्य में शामिल होने के() फेंकता InterruptedException अंतिम शून्य में शामिल होने के (लंबी millisec) फेंकता InterruptedException एक धागे पर लागू इन दोनों तरीकों में से किसी को एक कॉल प्रतीक्षा करें और नहीं होंगे लौट जब तक या तो धागा पूरा कर लिया है या यह समय समाप्त हो गया है क्रमशः निर्दिष्ट समय के बाद।

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

उदाहरण नीचे थ्रेड राज्यों के बीच संक्रमण को दर्शाता है। (1) पर एक थ्रेड थोड़ा (2) सोता है और फिर (3) पर लूप में कुछ गणना करता है, जिसके बाद धागा समाप्त हो जाता है। मुख्य() विधि थ्रेड (4) पर थ्रेड में धागे की निगरानी करता है, getState() विधि द्वारा लौटा धागा राज्य मुद्रित करता है। आउटपुट से पता चलता है कि थ्रेड रननेबल स्थिति के माध्यम से जाता है जब रन() विधि निष्पादित होने लगती है और फिर TIMED_WAITING स्थिति में सो जाती है। जागने पर, यह रननेबल स्थिति में लूप की गणना करता है, और रन() विधि समाप्त होने पर टर्मिनेटेड स्थिति में स्थानांतरित होता है।

उदाहरण: थ्रेड स्टेट्स

public class ThreadStates { 

    private static Thread t1 = new Thread("T1") { // (1) 
    public void run() { 
     try { 
     sleep(2);         // (2) 
     for(int i = 10000; i > 0; i--);   // (3) 
     } catch (InterruptedException ie){ 
     ie.printStackTrace(); 
     } 
    } 
    }; 

    public static void main(String[] args) { 
    t1.start(); 
    while(true) {         // (4) 
     Thread.State state = t1.getState(); 
     System.out.println(state); 
     if (state == Thread.State.TERMINATED) break; 
    } 
    } 
} 

कार्यक्रम से

संभावित उत्पादन:

RUNNABLE 
TIMED_WAITING 
... 
TIMED_WAITING 
RUNNABLE 
... 
RUNNABLE 
TERMINATED