एक रननेबल

Question

के समान उदाहरण के साथ दो धागे प्रारंभ करना क्या यह दो धागे को एक रननेबल के समान उदाहरण के साथ प्रारंभ करने के लिए खराब प्रोग्रामिंग है? एक रननेबल के अलग-अलग उदाहरणों के साथ आरंभ करने में क्या अंतर आएगा, और रननेबल के समान उदाहरण के लिए मेमोरी स्थानों को साझा करना क्या प्रदर्शन के साथ कुछ भी करना है?

public static void main(String[] args)throws Exception { 
    H h = new H(); 
    H h2 = new H(); 
    Thread j = new Thread(h); 
    j.setName("11"); 

    Thread jj = new Thread(h);//instead of new H() 
    jj.setName("22"); 
    j.start(); 
    jj.start(); 
} 

class H implements Runnable { 
    public void run() { 
     while(true) { 
      System.out.println(Thread.currentThread().getName()); 
     } 
    } 
} 

Answer 1

यह तब तक ठीक है जब तक आप जिस कोड को चला रहे हैं उसे उस समर्थन के लिए डिज़ाइन किया गया है। न केवल यह कई उदाहरणों के बजाय एक उदाहरण होने के द्वारा कुछ स्मृति को बचाएगा, लेकिन यदि वे थ्रेड को साझा डेटा के माध्यम से संवाद करने की कोशिश कर रहे हैं, तो यह बिल्कुल आवश्यक हो सकता है!

साझा राज्य के माध्यम से स्वीकार्य रूप से संचार करना जहां थ्रेडिंग अक्सर मुश्किल हो जाती है, इसलिए इसे ध्यान से करने की आवश्यकता होती है, लेकिन थ्रेडिंग सिस्टम के दृष्टिकोण से ही, दो धागे run विधि को कॉल करने में बिल्कुल कोई समस्या नहीं है एकल Runnable उदाहरण।

Answer 2

H के बाद से किसी भी घटना राज्य नहीं है, कई उदाहरण का उपयोग करते हुए कोई फर्क नहीं होगा। आपको Runnable उदाहरणों को संग्रहीत करना शुरू करते समय देखभाल करने की आवश्यकता है।

public class Main implements Runnable { 
    volatile int i; 
     public void run() { 
     for (i = 0; i < 100; i++) { 
      System.out.println(i); 
     } 
    } 

    public static void main(String[] args) { 
     Main a = new Main(); 
     Thread t1 = new Thread(a); 
     Thread t2 = new Thread(a); 
     t1.start(); 
     t2.start(); 
    }   
} 

printed क्या मिलता है? जब आपको धागे के बीच राज्य साझा करने की आवश्यकता होती है, तो java.util.concurrent में कक्षाओं का उपयोग करना एक अच्छा विचार है। वे मुख्य रूप से मल्टीथ्रेडिंग (Doug Lea, Concurrent Programming in Java के लेखक) में एक विशेषज्ञ द्वारा लिखे गए थे और कई लोगों द्वारा परीक्षण किया गया था। अपने आप को कुछ दिल का दर्द बचाओ। :)

Answer 3

क्या यह दो धागे को एक रननेबल के समान उदाहरण के साथ शुरू करने के लिए खराब प्रोग्रामिंग है?

विशेष रूप से नहीं। हालांकि, यदि Runnable इंस्टेंस में इंस्टेंस फ़ील्ड हैं, तो आपको यह सुनिश्चित करना होगा कि थ्रेड द्वारा फ़ील्ड्स तक पहुंच को ठीक से सिंक्रनाइज़ किया गया हो, और इससे कोड अधिक जटिल हो जाएगा।

एक रननेबल के अलग-अलग उदाहरणों के साथ आरंभ करने में क्या अंतर आएगा, और रननेबल के समान उदाहरण के लिए मेमोरी स्थानों को साझा करना क्या प्रदर्शन के साथ कुछ भी करना है?

स्मृति से अधिक थ्रेड के बीच एक Runnable उदाहरण साझा करके बचाया तुच्छ ... जब तक Runnable उदाहरण डेटा की एक महत्वपूर्ण राशि रखती है। (और अगर यह होता है, संभावना है कि इस उदाहरण गैर साझा करने योग्य बनाने के लिए कर रहे हैं।)

---

आपका H वर्ग एक उदाहरण है जहां बंटवारे उदाहरणों सुरक्षित है, लेकिन व्यर्थ के बाद से स्मृति बचत नगण्य है। (प्लेटफॉर्म के आधार पर Runnable ऑब्जेक्ट के साथ कोई उदाहरण फ़ील्ड लगभग 8 से 16 बाइट्स पर कब्जा नहीं करता है।)

Answer 4

आसानी से समझने के लिए (स्टीफन की टिप्पणी के आधार पर), उदाहरण को एक्सेस करने के प्रभाव के बारे में नीचे दिए गए प्रोग्राम ब्लॉक को जोड़ा गया रननेबल के एक ही उदाहरण के साथ गैर-सिंक्रनाइज़ किए गए ब्लॉक से परिवर्तनीय अप्रत्याशित परिणाम प्रदर्शित करता है।

public class SynchronizedInstanceMethod implements Runnable{ 

private int counter; 

public SynchronizedInstanceMethod(int counterValue){ 
    this.counter = counterValue; 
} 

private synchronized void displayMessage(){ 
    System.out.println(" Display Message "); 
} 

private void modifyCounter(){ 
    this.counter++; 
    System.out.println("Value -- "+ this.counter); 
} 

@Override 
public void run() { 
    this.displayMessage(); 
    this.modifyCounter(); 
} 

public static void main(String[] args) { 
    SynchronizedInstanceMethod instance = new SynchronizedInstanceMethod(5); 
    new Thread(instance).start(); 
    new Thread(instance).start(); 
} 
}