कृपया) थ्रेड रन (से उत्पादन समझाने और शुरू() पद्धतियों

Question

कृपया नीचे दिए गए कोड के उत्पादन में व्याख्या करते हैं:

अगर मैं th1.run() फोन, उत्पादन होता है:

EXTENDS RUN>> 
RUNNABLE RUN>> 

अगर मैं th1.start() फोन , आउटपुट है:

RUNNABLE RUN>> 
EXTENDS RUN>> 

यह असंगतता क्यों? कृपया समझाएँ।

class ThreadExample extends Thread{ 
    public void run() { 
     System.out.println("EXTENDS RUN>>"); 
    } 
} 

class ThreadExampleRunnable implements Runnable { 
    public void run() { 
     System.out.println("RUNNABLE RUN>>"); 
    } 
} 

class ThreadExampleMain{ 
    public static void main(String[] args) { 
     ThreadExample th1 = new ThreadExample(); 
     //th1.start(); 
     th1.run(); 

     ThreadExampleRunnable th2 = new ThreadExampleRunnable(); 
     th2.run(); 
    } 
} 

Answer 1

Thread.start() विधि, एक नया धागा शुरू होता है इस सूत्र के लिए प्रवेश बिंदु run() तरीका है। यदि आप सीधे रन() को कॉल करते हैं तो यह उसी थ्रेड में निष्पादित होगा। यह देखते हुए कि Thread.start() कॉलिंग निष्पादन का एक नया धागा शुरू करेगा, run() विधि के बाद विधि (जैसे आप उदाहरण में) शेष मुख्य विधि निष्पादित की जा सकती है।

th1.start() फोन और बार बार चलाने के लिए अपने मुख्य विधि बदलें, आपको लगता है कि देखेंगे कभी कभी यह आउटपुट:

EXTENDS RUN>> 
RUNNABLE RUN >> 

और कभी कभी यह आउटपुट:

RUNNABLE RUN >> 
EXTENDS RUN>> 

कैसे जावा शेड्यूल करने के लिए चुनता है पर निर्भर करता है आपके 2 धागे

इस पर java tutorial देखें।

Answer 2

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

तो जब आप th1.start() कहते हैं, आप कोड एक ही बार में दो धागे में क्रियान्वित किया है: मुख्य थ्रेड Th2 बनाने के लिए पर जाना होगा और फिर उसके run विधि कॉल, जबकि Th1 धागा अपनी ही run विधि कॉल करेंगे। इनका आदेश देने की कोई गारंटी नहीं है, क्योंकि वे समानांतर में निष्पादित कर रहे हैं।

Answer 3

जब आप th1.run() पर कॉल करते हैं तो आप वर्तमान थ्रेड में run विधि चला रहे हैं, इसलिए th2.run() पर कॉल करने से पहले ऐसा होना चाहिए।

जब आप th1.start() पर कॉल करते हैं तो आपको run विधि को नए थ्रेड पर कॉल किया जा रहा है। इस मामले में यह th2.run() पर कॉल के बाद हो रहा है। (वास्तव में, यह सैद्धांतिक रूप से संभव है कि यह th2.run() से पहले हो सकता है ... लेकिन thread.start() के वर्तमान और पिछले सूर्य कार्यान्वयन तुरंत नए धागा करने के लिए "उपज" करने के लिए वर्तमान धागा कारण नहीं है।)

यह एक दिखाता है जावा धागे का उपयोग करने के साथ आम गलती। यदि आप एक नए धागे पर सामान चलाने के लिए चाहते हैं, तो आपको thread.start() पर कॉल करना होगा। सीधे thread.run() पर कॉल करना लगभग हमेशा एक गलती है।

Answer 4

निष्पादन run() सिंक्रोनस है - start() निष्पादन एसिंक्रोनस है।

run() पर कॉल केवल नियमित सिंक्रोनस विधि कॉल हैं, और वे उस क्रम में होते हैं। th1.start() का उपयोग करके, एक नया धागा शुरू हो गया है - अब यह दो घोड़े की दौड़ है - दो रन विधियां अब स्वतंत्र रूप से निष्पादित कर रही हैं - अंतिम जीतने के लिए पहला, और आदेश के बारे में कोई गारंटी नहीं है।

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