Quando chiameresti thread.run () di java invece di thread.start ()?

Quando chiameresti Java thread.run()invece di thread.start()?

Potresti voler chiamare run () in un particolare unit test che riguarda strettamente la funzionalità e non la concorrenza.

Mai. Chiamare run () direttamente esegue semplicemente il codice in modo sincrono (nello stesso thread), proprio come una normale chiamata di metodo.

Preso dalle domande frequenti sui thread Java in stile codice :

D: Qual è la differenza tra i metodi start () e run () di un thread?

R: I metodi separati start () e run () nella classe Thread forniscono due modi per creare programmi in thread. Il metodo start () avvia l'esecuzione del nuovo thread e chiama il metodo run (). Il metodo start () ritorna immediatamente e il nuovo thread normalmente continua finché non ritorna il metodo run ().

Il metodo run () della classe Thread non fa nulla, quindi le sottoclassi dovrebbero sovrascrivere il metodo con il codice da eseguire nel secondo thread. Se un Thread viene istanziato con un argomento Runnable, il metodo run () del thread esegue invece il metodo run () dell'oggetto Runnable nel nuovo thread.

A seconda della natura del programma con thread, chiamare direttamente il metodo run () di Thread può fornire lo stesso output della chiamata tramite il metodo start (), ma in quest'ultimo caso il codice viene effettivamente eseguito in un nuovo thread.

L'esecuzione thread.run()non crea una nuova Threadin cui il tuo codice viene eseguito. Esegue semplicemente il codice nel Thread corrente da cui thread.run()viene richiamato il codice.

L'esecuzione thread.start()crea un nuovo thread a livello di sistema operativo in cui il run()metodo viene chiamato.

In sostanza:

Programmazione a thread singolo → Richiamo diretto del run()metodo

Programmazione multi thread → Richiamo del start()metodo

Inoltre, come altri hanno già detto, "testing" sembra essere l'unico caso consigliabile in cui puoi invocare run()direttamente dal tuo codice.

Questo è già stato accennato, ma solo per essere chiari: creare un nuovo oggetto Thread solo per chiamare il suo metodo run () è inutilmente costoso e dovrebbe essere una grande bandiera rossa. Sarebbe un disegno molto meglio, più disaccoppiato per creare un impl Runnable e (a) chiamata è di metodo run () direttamente, se questo è il comportamento desiderato, oppure (b) la costruzione di un nuovo thread con quella Runnable e avviare la discussione.

Meglio ancora, per un ulteriore disaccoppiamento, controlla l' Executorinterfaccia e il framework in JDK 5 e versioni successive. Ciò consente, in poche parole, di separare l'esecuzione dell'attività (l'istanza Runnable) da come dell'attività viene eseguita (l'implementazione dell'Executor, che potrebbe eseguire il Runnable nel Thread corrente, in un nuovo Thread, utilizzando un Thread esistente da un pool, e quant'altro).

Chiama thread.start(), chiamerà a sua volta thread.run(). Non riesco a pensare a un caso in cui vorresti bypassare thread.start()e andare direttamente athread.run()

I metodi separati start()e run()nella classe Thread forniscono due modi per creare programmi in thread. Il start()metodo avvia l'esecuzione del nuovo thread e chiama il run()metodo. Il start()metodo ritorna immediatamente e il nuovo thread normalmente continua finché il run()metodo non ritorna.

Il run()metodo della classe Thread non fa nulla, quindi le sottoclassi dovrebbero sovrascrivere il metodo con il codice da eseguire nel secondo thread. Se viene creata un'istanza di un thread con un argomento Runnable, il run()metodo del thread esegue il filerun() metodo dell'oggetto Runnable nel nuovo thread.

A seconda della natura del programma con thread, la chiamata run()diretta del metodo Thread può fornire lo stesso output della chiamata tramitestart() metodo, ma in quest'ultimo caso il codice viene effettivamente eseguito in un nuovo thread.

riferimento

Se la domanda era: "perché viene chiamato il metodo di avvio del thread invece di eseguire direttamente il metodo", ho risposto con un codice di esempio di seguito. Spero che questo chiarisca. Nell'esempio seguente:

/*
By calling t1.start(), 
we are getting the main calling thread returned immediately 
after the t1.start() called and is ready to proceed for other 
operations.And the thread t1 starts executing the run method of the object r. 
Hence the the output will be:

      I am the main thread , i created thread t1 and had it execute run method, which is currently looping from 0 to 1000000

      I am done executing run method of testThread

*/


/* If we call t1.run() instead of t1.start(), (just replace t1.start() with t1.run() in the code for testing)
 its like a regular method call and the main thread will not return until the run method completes, 
 hence the output will be:

         I am done executing run method of testThread

         I am the main thread , i created thread t1 and had it execute run method, which is currently looping for i to 1000000

*/


class testThread implements Runnable{

 public void run()
 {
     for(int i=0;i<1000000;i++){} //a simple delay block to clarify.

     System.out.println("I am done executing run method of testThread");

 }  
}

public class mainClass{

   public static void main(String [] args)
    {
          testThread r = new testThread();
          Thread t1 = new Thread(r);
          t1.start();  /* Question is: can we call instead t1.run() */  
          System.out.println("I am the main thread , i created thread t1 and had it execute run method, which is currently looping for i to 1000000");

    }
}

Quando vuoi che venga eseguito in modo sincrono. Chiamare il metodo run non ti darà effettivamente il multi-threading. Il metodo start crea un nuovo thread che chiama il metodo run.

Se vuoi eseguire il contenuto di run () come faresti con qualsiasi altro metodo. Non per iniziare una discussione, ovviamente.

Supponendo che si conosca l'avvio e l'utilizzo del metodo di esecuzione, ovvero sincrono e asincrono; Il metodo run può essere utilizzato solo per testare la funzionalità.

Inoltre, in alcune circostanze, la stessa classe di thread può essere utilizzata in due luoghi diversi con requisiti di funzionalità di sincronizzazione e asincronia avendo due oggetti diversi con il proprio metodo di esecuzione e il metodo di avvio dell'altro che vengono richiamati.

Almeno nella JVM 1.6., C'è un po 'di controllo ed esecuzione è chiamato in modo nativo:

 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();
        group.add(this);
        start0();
        if (stopBeforeStart) {
        stop0(throwableFromStop);
    }
    }

    private native void start0();

Solo una nota agli ottimi commenti sopra: a volte scrivi un codice multi-thread che usa il metodo "start" per eseguire thread diversi. Troverai molto più facile se usi "run" (invece di "start) per il debug poiché rende il codice da eseguire in modo sincrono e il debug è molto più semplice.

public class TestClass implements Runnable {
    public static void main(String[] args) {
        TestClass tc = new TestClass();

        Thread t1 = new Thread(tc);
        System.out.println("Before Starting Thread " + Thread.currentThread().hashCode());
        t1.start();
        System.out.println("After Starting Thread " + Thread.currentThread().hashCode());
    }

    @Override
    public void run() {
        System.out.println("TestClass Run method is  Running with thread " + Thread.currentThread().hashCode());        
    }
}