Wenn ein Thread zerstört wird, werden die Variablen zerstört?

Question

Ich wollte Elemente der Warteschlange von 2 Threads verarbeiten und OutputQueue in der gleichen Reihenfolge wie Eingabe vorbereiten. Ich muss noch einige synchronisierte Blöcke erstellen, aber ich bleibe bei den folgenden Fragen.

1. Leere OutputQueue zurückgegeben
2. Bin ich dies richtig tun.

ThreadMailClass.java

public class ThreadMainClass { 

    public static void main(String[] args) { 
     int[] inputQueue={2,3,4,5,6}; 
     processJobs(inputQueue); 
    } 

    public static void processJobs(int[] inputQueue){ 

     Queue<Integer> queue = new LinkedList<Integer>(); 
     for(int i:inputQueue){ 
      queue.add(i); 
     } 
     System.out.println("Input Queue Size:" + queue.size()); 

     HeavyWorkRunnable hr = new HeavyWorkRunnable(); 

     Thread t1 = new Thread(new HeavyWorkRunnable(queue),"t1"); 
     Thread t2 = new Thread(new HeavyWorkRunnable(queue),"t2"); 

     t1.start(); 
     t2.start(); 

     try { 
      t1.join(); 
     t2.join(); 

      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 
//This method is returning empty Queue. 
     Queue<Integer> outputQueue = hr.getOutputQueue(); 
     System.out.println("Printing Output Queue.." + outputQueue.size()); 
     for(Integer i:outputQueue) 
      System.out.println(i); 
     System.out.println("Printing Done"); 


    } 

HeavyWorkRunnable.java

public class HeavyWorkRunnable implements Runnable { 

    private Queue<Integer> outputQueue = new LinkedList<Integer>(); 
    private Queue<Integer> inputQueue; 

    public HeavyWorkRunnable() { 

     } 
    public HeavyWorkRunnable(Queue<Integer> inputQueue) { 
     this.inputQueue = inputQueue; 
     } 

    @Override 
    public void run() { 
     System.out.println("Doing heavy processing - START "+Thread.currentThread().getName()); 
     try { 
      processInputQueue(); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
     System.out.println("Doing heavy processing - END "+Thread.currentThread().getName()); 
    } 

    private void processInputQueue() { 
     while(inputQueue.peek()!=null){ 
      System.out.println(Thread.currentThread().getName() + "-->input size -->"+ inputQueue.size()); 
      outputQueue.add(inputQueue.remove()); 
      System.out.println(Thread.currentThread().getName() + "-output size -->"+ outputQueue.size()); 
     } 
    } 

    public Queue<Integer> getOutputQueue() { 
     return this.outputQueue; 
    } 
} 

Answer 1

Wenn ein Thread zerstört werden die Variablen zerstört?

Wenn der run() Methodenaufruf beendet ist, werden die Fadenstapel verworfen, und der Bezugsfaden auf seine Runnable genullt wird. Zu diesem Zeitpunkt sind alle lokalen Variablen der run()-Methode außerhalb des Gültigkeitsbereichs.

Wenn die Runnable wird unerreichbar ist es Müll gesammelt. Der GC wird letztendlich die Instanzvariablen des Runnable "zerstören".

---

Bin ich dies richtig tun.

würde ich ein ExecutorService, verwenden und befassen sich mit dem Thema der Ausgänge der Bestellung durch eine Liste von Future Erstellen von Objekten durch die submit(...) Methode zurückgegeben.

In Ihrem Code, Sie scheinen drei verschiedene Instanz von HeavyWorkRunnable zu haben, und Sie scheinen die Ausgabewarteschlange von der Instanz werden abgerufen, die Sie nicht Pass zu einem Faden tat. Das sieht für mich nicht korrekt aus. Es gibt auch Probleme mit (fehlender) Synchronisation in der geteilten Eingabewarteschlange. Das könnte zu Race Conditions und Speichersichtbarkeitsproblemen führen.

Leere OutputQueue wird

zurück

Ja. Das ist eine Konsequenz des obigen "drei Instanzen" -Problems.