Si prega di spiegare l’output dai metodi Thread run () e start ()

Si prega di spiegare l’output del seguente codice:

Se chiamo th1.run() , l’output è:

 EXTENDS RUN>> RUNNABLE RUN>> 

Se chiamo th1.start() , l’output è:

 RUNNABLE RUN>> EXTENDS RUN>> 

Perché questa incoerenza? Spiega per favore.

 class ThreadExample extends Thread{ public void run() { System.out.println("EXTENDS RUN>>"); } } class ThreadExampleRunnable implements Runnable { public void run() { System.out.println("RUNNABLE RUN>>"); } } class ThreadExampleMain{ public static void main(String[] args) { ThreadExample th1 = new ThreadExample(); //th1.start(); th1.run(); ThreadExampleRunnable th2 = new ThreadExampleRunnable(); th2.run(); } } 

Il metodo Thread.start() avvia un nuovo thread, il punto di ingresso per questo thread è il metodo run() . Se chiami run () direttamente verrà eseguito nello stesso thread. Dato che chiamare Thread.start() inizierà un nuovo thread di esecuzione, il metodo run() può essere chiamato dopo (come nell’esempio) il resto del metodo main viene eseguito.

Cambia il tuo metodo principale per chiamare th1.start() ed esegui ripetutamente, vedrai che a volte emette:

 EXTENDS RUN>> RUNNABLE RUN >> 

e qualche volta emette:

 RUNNABLE RUN >> EXTENDS RUN>> 

a seconda di come java sceglie di pianificare i tuoi 2 thread.

Guarda il tutorial di Java su questo.

Quando chiamate th1.run() state eseguendo il metodo run nel thread corrente, quindi deve succedere prima di chiamare a th2.run() .

Quando chiamate th1.start() il metodo run viene chiamato su un nuovo thread. In questo caso accade dopo la chiamata a th2.run() . (In realtà, è teoricamente ansible che possa accadere prima di th2.run() … ma le implementazioni attuali e precedenti di thread.start() non fanno in modo che il thread corrente “ceda” immediatamente al nuovo thread. )

Questo illustra un errore comune con l’utilizzo di thread Java. Se vuoi eseguire roba su un nuovo thread, devi chiamare thread.start() . thread.run() direttamente thread.run() è quasi sempre un errore.

Quando chiamate .run() , il metodo viene chiamato e il codice all’interno viene eseguito come qualsiasi altro metodo. Se si chiama .start() su un thread, tuttavia, il metodo run() verrà eseguito in quel thread e non in modo sequenziale nel thread principale.

Quindi quando chiamate th1.start() , avete codice in esecuzione in due thread contemporaneamente: il thread principale andrà a creare th2 e poi chiamerà il suo metodo run , mentre il thread th1 chiamerà il proprio metodo run . Non vi è alcuna garanzia sull’ordinazione di questi, perché sono eseguiti in parallelo.

esecuzione run() è sincrono – l’esecuzione start() è asincrona.

Le chiamate a run() sono solo una normale chiamata di metodo sincrono e avvengono in questo ordine. Usando th1.start() , viene avviato un nuovo thread – ora è un cavallo due volte – i due metodi di esecuzione ora vengono eseguiti indipendentemente: il primo al traguardo vince, e non vi è alcuna garanzia sull’ordine.

Ma se l’ordine non è garantito, perché la nuova Discussione stampa più tardi la maggior parte del tempo? In pratica, ci vuole del tempo per iniziare un nuovo thread, quindi al momento in cui viene avviato, l’altro metodo run() è già in esecuzione. Anche su un computer multi-core, in cui entrambi i thread possono essere eseguiti contemporaneamente, il nuovo thread verrà in genere il risultato finale, poiché l’avvio del thread richiede più lavoro.