Quand appelleriez-vous thread.run () de java au lieu de thread.start ()?

Quand appelleriez-vous Java au thread.run()lieu de thread.start()?

Vous voudrez peut-être appeler run () dans un test unitaire particulier qui concerne strictement la fonctionnalité et non la concurrence.

Jamais. L'appel direct de run () exécute simplement le code de manière synchrone (dans le même thread), tout comme un appel de méthode normal.

Tiré de la FAQ sur les threads Java de style de code :

Q: Quelle est la différence entre les méthodes start () et run () d'un thread?

R: Les méthodes distinctes start () et run () de la classe Thread fournissent deux façons de créer des programmes threadés. La méthode start () démarre l'exécution du nouveau thread et appelle la méthode run (). La méthode start () retourne immédiatement et le nouveau thread continue normalement jusqu'au retour de la méthode run ().

La méthode run () de la classe Thread ne fait rien, donc les sous-classes doivent remplacer la méthode avec du code à exécuter dans le deuxième thread. Si un Thread est instancié avec un argument Runnable, la méthode run () du thread exécute à la place la méthode run () de l'objet Runnable dans le nouveau thread.

Selon la nature de votre programme threadé, l'appel direct de la méthode Thread run () peut donner le même résultat que l'appel via la méthode start (), mais dans ce dernier cas, le code est en fait exécuté dans un nouveau thread.

L'exécution thread.run()ne crée pas de nouveau Threaddans lequel votre code est exécuté. Il exécute simplement le code dans le Thread actuel à partir duquel le thread.run()code est appelé.

L'exécution thread.start()crée un nouveau thread au niveau du système d'exploitation dans lequel la run()méthode est appelée.

En substance:

Programmation à un seul thread → Appel direct de la run()méthode

Programmation multithread → Appel de la start()méthode

De plus, comme d'autres l'ont mentionné, «tester» semble être le seul cas recommandé dans lequel vous pouvez invoquer run()directement à partir de votre code.

Cela a déjà été évoqué, mais juste pour être clair: créer un nouvel objet Thread uniquement pour appeler sa méthode run () est inutilement coûteux et devrait être un drapeau rouge majeur. Ce serait une conception bien meilleure et plus découplée pour créer un impl Runnable et soit (a) appeler sa méthode run () directement si c'est le comportement souhaité, soit (b) construire un nouveau Thread avec ce Runnable et démarrer le Thread.

Mieux encore, pour encore plus de découplage, consultez l' Executorinterface et le framework dans JDK 5 et plus récent. Cela vous permet, en un mot, de découpler l'exécution de la tâche (l'instance Runnable) de la façon dont elle est exécutée (l'implémentation Executor, qui peut exécuter le Runnable dans le Thread actuel, dans un nouveau Thread, en utilisant un Thread existant d'un pool, et ainsi de suite).

Appelez thread.start(), il appellera à son tour thread.run(). Je ne peux pas penser à un cas où vous voudriez contourner thread.start()et aller directement àthread.run()

Les méthodes distinctes start()et run()de la classe Thread fournissent deux méthodes pour créer des programmes threadés. La start()méthode démarre l'exécution du nouveau thread et appelle la run()méthode. La start()méthode retourne immédiatement et le nouveau thread continue normalement jusqu'à ce que la run()méthode retourne.

La run()méthode de la classe Thread ne fait rien, donc les sous-classes doivent remplacer la méthode avec du code à exécuter dans le deuxième thread. Si un thread est instancié avec un argument Runnable, la run()méthode du thread exécute la run()méthode de l'objet Runnable dans le nouveau thread à la place.

Selon la nature de votre programme threadé, l'appel run()direct de la méthode Thread peut donner le même résultat que l'appel via la start()méthode, mais dans ce dernier cas, le code est en fait exécuté dans un nouveau thread.

référence

Si la question était - "pourquoi la méthode de démarrage de thread est appelée au lieu de la méthode d'exécution directement" alors j'ai répondu avec un exemple de code ci-dessous. J'espère que cela clarifie. Dans l'exemple ci-dessous:

/*
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");

    }
}

Lorsque vous souhaitez qu'il s'exécute de manière synchrone. L'appel de la méthode run ne vous donnera pas réellement de multi-threading. La méthode start crée un nouveau thread qui appelle la méthode run.

Si vous voulez exécuter le contenu de run () comme vous le feriez pour toute autre méthode. Pas pour démarrer un fil, bien sûr.

En supposant que vous connaissez l'utilisation de la méthode de démarrage et d'exécution, c.-à-d. Synchrone ou asynchrone; La méthode run peut être utilisée uniquement pour tester la fonctionnalité.

De plus, dans certaines circonstances, la même classe de thread peut être utilisée à deux endroits différents avec des exigences de fonctionnalité de synchronisation et d'asynchrone en ayant deux objets différents avec une méthode d'exécution et une autre méthode de démarrage appelée.

Au moins dans la JVM 1.6., Il y a un peu de vérification et l'exécution est appelée nativement:

 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();

Juste une note aux excellents commentaires ci-dessus: parfois vous écrivez un code multi-thread qui utilise la méthode "start" pour exécuter différents threads. Vous trouverez cela beaucoup plus facile si vous utilisez "run" (au lieu de "start) pour le débogage car cela permet au code de s'exécuter de manière synchrone et de le déboguer beaucoup plus facilement.

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());        
    }
}