एक थ्रेड अपने काम को खत्म करने के बाद एक मूल्य कैसे वापस कर सकता है?

Question

मान लें कि हमारे पास यह सरल उदाहरण है:

public Example extends Thread{ 

    String temp;  

    public Example(){ 
    } 

    @Override 
    public void run(){ 
     . 
     . 
     . 
     . 
     temp = "a_value"; 
    } 

    public static void main(String[] args) { 

     Example th = new Example(); 
     th.start(); 
    } 

} 

अपने काम को खत्म करने के बाद थ्रेड मुझे स्ट्रिंग अस्थायी कैसे लौटा सकता है?

Answer 1

आप इसे पर्यवेक्षक पैटर्न द्वारा प्राप्त कर सकते हैं। धागे को खत्म करने पर सभी श्रोताओं को यह सूचित किया जाता है कि यह समाप्त हो गया है और वे मूल्य (गेटटर के माध्यम से) को पुनर्प्राप्त कर सकते हैं। या यह पहले ही गणना मूल्य भेज सकता है।

या आप एक कार्य का उपयोग कर सकते हैं, FutureTask देखें, एक रननेबल (वास्तव में एक कॉल करने योग्य के नीचे बताया गया है) जो परिणाम देता है और अपवाद फेंक सकता है।

Answer 2

Future इंटरफ़ेस जावाडोक देखें। इसमें नमूना उपयोग है जो आपको दिखा रहा है कि यह कैसे करें। (1.5 और नए संस्करणों में उपलब्ध है) (अपेक्षाकृत) नई Callable<T> Runnable की बजाय

Answer 3

उपयोग करें:

import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutionException; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Future; 


public class Main { 

    public static void main(final String[] argv) { 
     final ExecutorService service; 
     final Future<String> task; 

     service = Executors.newFixedThreadPool(1);   
     task = service.submit(new Foo()); 

     try { 
      final String str; 

      // waits the 10 seconds for the Callable.call to finish. 
      str = task.get(); // this raises ExecutionException if thread dies 
      System.out.println(str); 
     } catch(final InterruptedException ex) { 
      ex.printStackTrace(); 
     } catch(final ExecutionException ex) { 
      ex.printStackTrace(); 
     } 

     service.shutdownNow(); 
    } 
} 

class Foo implements Callable<String> { 
    public String call() { 
     try { 
      // sleep for 10 seconds 
      Thread.sleep(10 * 1000); 
     } catch(final InterruptedException ex) { 
      ex.printStackTrace(); 
     } 

     return ("Hello, World!"); 
    } 
} 

Answer 4

आप नहीं करना चाहते हैं:

यहाँ एक (सरल) उदाहरण है कॉल करने योग्य ऑब्जेक्ट्स का उपयोग करने के लिए समाधान को स्वैप करने के लिए आप कतारों का भी उपयोग कर सकते हैं और परिणाम को थ्रेड से वापस कर सकते हैं।
मैं इस तरह अपने उदाहरण फिर से लिखा है:

import java.util.PriorityQueue; 
import java.util.Queue; 

public class GetResultFromThread { 
    public static void main(String[] args) throws Exception { 
     Queue<String> queue = new PriorityQueue<String>(); 
     int expectedResults = 2; 
     for (int i = 0; i < expectedResults; i++) { 
      new Example(queue).start(); 
     } 

     int receivedResults = 0; 
     while (receivedResults < expectedResults) { 
      if (!queue.isEmpty()) { 
       System.out.println(queue.poll()); 
       receivedResults++; 
      } 
      Thread.sleep(1000); 
     } 
    } 
} 

class Example extends Thread { 
    private final Queue<String> results; 

    public Example(Queue<String> results) { 
     this.results = results; 
    } 

    @Override 
    public void run() { 
     results.add("result from thread"); 
    } 
} 

ध्यान दें कि आप तुल्यकालन और संगामिति के बारे में सोच जायेगा!