Posso eseguire un thread all'interno di un thread in java?

Question

In Java ho la necessità di implementare una classe che estende Thread all'interno di un'altra classe simile. È possibile?

Un esempio di quello che sto cercando di fare è il seguente (semplificato) frammento:

// The first layer is a Thread 
public class Consumer extends Thread { 

    // Variables initialized correctly in the Creator 
    private BufferManager BProducer = null; 

    static class Mutex extends Object {} 
    static private Mutex sharedMutex = null; 


    public Consumer() { 
     // Initialization of the thread 
     sharedMutex = new Mutex(); 

     BProducer = new BProducer(sharedMutex); 
     BProducer.start(); 
    } 


    public void run() { 

     int data = BProducer.getData(); 

     ///// .... other operations 
    } 


    ////// ...... some code 

    // Also the second layer is a Thread 
    private class BufferManager extends Thread { 

     Mutex sharedMutex; 
     int data; 

     public BufferManager(Mutex sM) { 
      sharedMutex = sM; 
     } 

     public int getData(Mutex sM) { 
      int tempdata; 
      synchronized(sharedMutex) { 
       tempdata = data; 
      } 
      return tempdata; 
     } 

     public void run() { 
      synchronized(sharedMutex) { 
       data = getDataFromSource(); 
      } 
      ///// .... other operations on the data 
     } 
    } 
} 

il secondo thread è implementata direttamente all'interno del primo. Inoltre mi piacerebbe sapere se l'implementazione di un Mutex come quello funzionerà. In caso contrario, c'è un modo migliore (standard) per farlo?

Grazie in anticipo.

Answer 1

L'Thread non viene eseguito "all'interno", ma piuttosto affiancato.

Quindi sì, è possibile avviare un altro Thread per l'esecuzione side-by-side con gli altri due Thread. In effetti, qualsiasi Thread può avviare un altro Thread (a condizione che il sistema operativo lo consenta).

Answer 2

Sì, questo dovrebbe funzionare e il Mutex condiviso dovrebbe fare il suo lavoro. Fuori dalla paranoia, farei entrambe le dichiarazioni mutex final per evitare problemi di "fuga". per esempio.

final Mutex sharedMutex; 

Un suggerimento: forse questo è il mio stile, ma per il codice come questo mi rado si estendono Thread. Basta implementare Runnable invece. IMO è un po 'meno confuso (YMMV qui). Inoltre, quando inizi a utilizzare utilità di concorrenza avanzate come Executor, si occupano di Runnables, non di Thread.