जावा अनंत लूप प्रदर्शन

Question

मैं एक धागा ही काम करने के लिए जब एक निश्चित परिस्थिति में आता है कि है नहीं तो यह सिर्फ एक खाली अनंत लूप से अधिक दोहराता:।

public void run() { 
    while(true) { 
     if(ball != null) { 
      // do some Calculations 
     } 
    } 
} 

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

संपादित करें: तो क्या यह एक अच्छा समाधान है? या यह एक अलग विधि (प्रदर्शन से संबंधित) का उपयोग करना बेहतर है?

private final Object standBy = new Object(); 

public void run() { 
    while(true) { 
     synchronized (standBy) { 
      while(ball != null) // should I use while or if here? 
       try{ standBy.wait() } 
       catch (InterruptedException ie) {} 
     } 
     if(ball != null) { 
      // do some Calculations 
     } 
} 

public void handleCollision(Ball b) { 
    // some more code.. 
    ball = b; 
    synchronized (standBy) { 
     standBy.notify(); 
    } 
} 

Answer 1

आप धागे को सोने के लिए डालने पर विचार करना चाहेंगे और केवल तभी जाग रहे हैं जब आपका 'बॉल' चर सत्य हो जाए। java.util.concurrent कक्षाओं का उपयोग करने के लिए बहुत कम स्तर, wait और notify कथन का उपयोग करने से ऐसा करने के कई तरीके हैं जो ऐसा करने में कम त्रुटि प्रवण तरीका प्रदान करते हैं। condition इंटरफेस के लिए प्रलेखन पर एक नज़र डालें। BlockingQueue जैसी डेटा संरचना भी एक समाधान होगी।

Answer 2

हां, यह निश्चित रूप से प्रदर्शन को प्रभावित करेगा। प्रदर्शन बढ़ाने के लिए, आप अपने कोड में थोड़ी देर देरी (500ms या 1000ms या इससे भी अधिक कहें) डालने पर विचार कर सकते हैं कि आपके लिए कितना महत्वपूर्ण समय है।

Answer 3

अपने धागे के बीच BlockingQueue साझा करें।

class Producer implements Runnable { 
    private final BlockingQueue queue; 
    Producer(BlockingQueue q) { queue = q; } 
    public void run() { 
    try { 
     while (true) { queue.put(produce()); } 
    } catch (InterruptedException ex) { ... handle ...} 
    } 
    Object produce() { ... } 
} 

class Consumer implements Runnable { 
    private final BlockingQueue queue; 
    Consumer(BlockingQueue q) { queue = q; } 
    public void run() { 
    try { 
     while (true) { consume(queue.take()); } 
    } catch (InterruptedException ex) { ... handle ...} 
    } 
    void consume(Object x) { ... } 
} 

Answer 4

हां यह करता है। यह busy waiting का सबसे सरल कार्यान्वयन है, और जब भी संभव हो से बचा जाना चाहिए। प्रतीक्षा/अधिसूचना या java.util.concurrent तंत्र का उपयोग करें। हो सकता है कि आप अधिक उपयोगी प्रतिक्रिया प्राप्त करने के लिए वास्तव में क्या हासिल करना चाहते हैं, इसके बारे में अधिक विशिष्ट होना चाहिए।