Come interrompere il thread di ritorno prima Join() è chiamato

Question

Questa è una domanda puramente teorica in quanto non sono sicuro che le condizioni per causare questo problema sarebbero comuni.

Dire per esempio che avete un filo che si kick off con il suo metodo start:

Thread c = new Thread(); 
c.start(); 

Poi subito dopo, si chiama il metodo Join() sul filo di raccontare il metodo si è in attendere fino a quando il thread è stato eseguito per continuare.

c.join(); 

Non è forse una possibilità che il filo potrebbe essere eseguito e finire prima che il metodo join viene chiamato, lasciando quindi il metodo di conoscenza che ha dovuto aspettare per c per terminare prima che ha continuato? Suppongo che potresti provare a chiamare il metodo join() prima di chiamare il metodo start(), ma ogni volta che ho provato questo nei casi di test, c'è un errore.

Qualcuno sa una possibile soluzione per questo o la JVM lo gestisce? Come ho detto, non sono stato in grado di attivare questo tipo di situazione, ma teoricamente è possibile ...

Answer 1

In base al codice sorgente Thread#join(long millis), il metodo isAlive() viene utilizzato per verificare lo stato del thread.

/** 
* Tests if this thread is alive. A thread is alive if it has 
* been started and has not yet died. 
* 
* @return <code>true</code> if this thread is alive; 
*   <code>false</code> otherwise. 
*/ 
public final native boolean isAlive(); 

Questo metodo restituisce ovviamente false se il filo è terminato, così thread.join() verrà immediatamente uscita.

Answer 2

La semantica del metodo join significa "attendere che il thread di collegamento sia terminato", e questo è praticamente lo standard in ogni linguaggio di programmazione che supporta il multi-threading. Pertanto, è perfettamente possibile unire un thread già finito, la JVM rileverà semplicemente che è già terminata e procede con l'esecuzione del codice.

Answer 3

c.join() significa che il thread attualmente in esecuzione deve attendere il completamento di c prima di terminare. Se c viene eseguito completamente prima che venga effettuata la chiamata a c.join(), allora tale condizione è soddisfatta, poiché c ha completato l'esecuzione. Il metodo con cui chiami c.join() non "lo saprebbe"; c.join() sarebbe semplicemente come un non-op.

Answer 4

join() restituirà immediatamente se il thread non è in esecuzione.

Answer 5

È possibile chiamare join() prima dell'avvio di un thread, ma poiché il thread non è stato avviato, join() restituirà immediatamente.

Se join() viene chiamato dopo l'avvio della discussione e la discussione è terminata, anche join() restituirà immediatamente.

L'unica volta join() bloccherà è mentre il Thread.isAlive()

Questo codice funziona OK ...

public static void main(String[] args) throws InterruptedException 
    { 
     Thread t = new Thread(new Runnable() 
     { 
     public void run() 
     { 
      System.out.println("thread"); 
     } 
     }); 
     t.join(); 
     System.out.println("joined"); 

     Thread.sleep(2000); 
     System.out.println("call start"); 
     t.start(); 
    } 

Answer 6

perché non usi CountdownLatch con callable e futuro. Ad esempio, http://sycure.wordpress.com/2012/01/21/example-using-java-future-and-countdownlatch/