Qual è la differenza tra Thread.start() e Thread.run()?

Question

Perché chiamiamo il metodo start(), che a sua volta chiama il metodo run()?
Non possiamo effettuare direttamente una chiamata a run()?

Si prega di fornire un esempio in cui vi è una differenza.

Answer 1

No, non è possibile. L'esecuzione di chiamata eseguirà il metodo run() nello stesso thread, senza iniziare il nuovo thread.

Answer 2

Perché si chiama il metodo start(), che a sua volta chiama il metodo run()?

No, questo è impreciso. start() a sua volta non chiama il metodo di esecuzione. invece avvia il thread che esegue il metodo run. Questo è nativo

Non è possibile effettuare direttamente una chiamata a run()?

Se si chiama run() direttamente non si avvia il thread, si esegue semplicemente il metodo sullo stesso metodo di chiamata.

Si prega di fornire un esempio in cui vi è una differenza.

Ci sono milioni sul web. Quindi non duplicare.

Answer 3

Perché start() non chiama semplicemente run(). Inizia una nuova discussione e in tale thread chiamate run().

Answer 4

non è possibile eseguire direttamente il metodo run(). Ogni volta che si avvia il thread usando thread.start(), viene chiamato il metodo run() ed eseguita l'ulteriore operazione.

Answer 5

In realtà thread.start() crea un nuovo thread e dispone di uno scenario di esecuzione.

ma thread.run() non crea alcun nuovo thread, ma esegue il metodo di esecuzione nel thread corrente.

Quindi, se si utilizza thread.run(), allora pensa che a che cosa serve il multi-threading se si desidera che solo un thread esegua tutto il metodo run.

Answer 6

differenza principale è che quando programma chiama start() metodo viene creato un nuovo thread e codice all'interno metodo run() viene eseguito in nuova Thread.If si chiama run() metodo direttamente non viene creato nessun nuovo Discussione e il codice dentro run() verrà eseguito sul thread corrente.

La maggior parte delle volte chiamata run() è un bug o errore di programmazione perché il chiamante ha intenzione di chiamare start() per creare un nuovo thread e questo errore può essere rilevato da molti strumenti di copertura del codice statico come findbugs. Se si desidera eseguire un'attività che richiede molto tempo di chiamare sempre il metodo start() altrimenti il ​​thread principale si bloccherà durante l'esecuzione di un'attività che richiede tempo se si chiama direttamente il metodo run(). Un'altra differenza tra start vs run in thread Java è che non è possibile chiamare il metodo start() due volte su oggetto thread.una volta avviato, la seconda chiamata di start() genererà IllegalStateException in Java mentre è possibile chiamare il metodo run() due volte.

Answer 7

Se si chiama run() direttamente, il codice viene eseguito nel thread chiamante. Chiamando start(), viene creato un nuovo thread diverso dal thread principale ed eseguito in parallelo.

Answer 8

Perché start(); è sincronizzato e run(); è un metodo semplice/regolare. Lo stesso che java sa di iniziare l'esecuzione dal metodo main();. Come filo sa di esecuzione a partire dal run();

Ecco il codice sorgente da Thread Classe:

run(); codice:

@Override 
public void run() { // overriding from Runnable 
     if (target != null) { 
      target.run(); 
     } 
} 

start(); codice:

public synchronized void start() { 
     /** 
     * This method is not invoked for the main method thread or "system" 
     * group threads created/set up by the VM. Any new functionality added 
     * to this method in the future may have to also be added to the VM. 
     * 
     * A zero status value corresponds to state "NEW". 
     */ 
     if (threadStatus != 0) 
      throw new IllegalThreadStateException(); 

     /* Notify the group that this thread is about to be started 
     * so that it can be added to the group's list of threads 
     * and the group's unstarted count can be decremented. */ 
     group.add(this); 

     boolean started = false; 
     try { 
      start0(); 
      started = true; 
     } finally { 
      try { 
       if (!started) { 
        group.threadStartFailed(this); 
       } 
      } catch (Throwable ignore) { 
       /* do nothing. If start0 threw a Throwable then 
        it will be passed up the call stack */ 
      } 
     } 
    } 

Insomma start(); è il manager di thread, come gestire ecc. e run(); è il punto critico del funzionamento del filo.

Answer 9

questo è il lavoro svolto dal metodo start

synchronized public void start() 
{ 
    //it calls start0() method internally and start0() method does below 
    //create a real child thread and register with thread scheduler 
    //create runtime stack for child thread 
    //call run() on underlying Runtime object 
}