method - thread new runnable java

¿Cuándo llamarías a thread.run() de java en lugar de thread.start()?

Question

¿Cuándo llamarías a thread.run() Java en lugar de thread.start() ?

Answer 1

Al menos en el JVM 1.6., Hay un poco de comprobación y la ejecución se llama de forma nativa:

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

Answer 2

Cuando quieres que se ejecute sincrónicamente. Llamar al método de ejecución en realidad no le dará múltiples subprocesos. El método de inicio crea un nuevo hilo que llama al método de ejecución.

Answer 3

Es posible que desee llamar a run () en una prueba de unidad particular que se refiere estrictamente a la funcionalidad y no a la concurrencia.

Answer 4

Esto ya se ha aludido, pero solo para ser claros: la creación de un nuevo objeto Thread solo para llamar a su método run () es innecesariamente costoso y debería ser una gran señal de advertencia. Sería un diseño mucho mejor y más desacoplado crear una Runnable impl y (a) llamar directamente a su método run () si ese es el comportamiento deseado, o (b) construir un Thread nuevo con ese Runnable e iniciar el Thread.

Mejor aún, para obtener aún más desacoplamiento, consulte la interfaz y el marco Executor en JDK 5 y posteriores. Esto le permite, en pocas palabras, desacoplar la ejecución de la tarea (la instancia Runnable) de cómo se ejecuta (la implementación Executor, que podría ejecutar Runnable en el Thread actual, en un Thread nuevo, utilizando un Thread existente de un grupo, Y qué no).

Answer 5

La ejecución de thread.run() no crea un nuevo Thread en el que se ejecuta el código. Simplemente ejecuta el código en el subproceso actual desde el que se invoca el código thread.run() .

La ejecución de thread.start() crea un nuevo subproceso de nivel de sistema operativo en el que se llama al método run() .

En esencia:

Programación Single Thread → Llamando directamente al método run()

Programación multiproceso → Llamar al método start()

Además, como han mencionado otros, "prueba" parece ser el único caso aconsejable en el que puede invocar run() directamente desde su código.

Answer 6

Llamar a thread.start() , a su vez llamará a thread.run() . No se puede pensar en un caso en el que desee omitir thread.start() e ir directamente a thread.run()

Answer 7

Los métodos start() y run() separados en la clase Thread proporcionan dos formas de crear programas enhebrados. El método start() inicia la ejecución del nuevo hilo y llama al método run() . El método start() regresa inmediatamente y el nuevo subproceso normalmente continúa hasta que el método run() retorna.

El método run() clase Thread no hace nada, por lo que las subclases deben anular el método con código para ejecutar en el segundo hilo. Si se crea una instancia de un subproceso con un argumento ejecutable, el método run() del subproceso ejecuta el método run() del objeto ejecutable en el nuevo subproceso en su lugar.

Dependiendo de la naturaleza de su programa enhebrado, llamar directamente al método Thread run() puede dar el mismo resultado que llamar mediante el método start() , pero en este último caso el código se ejecuta realmente en un nuevo hilo.

reference

Answer 8

Nunca. Llamar a ejecutar () directamente solo ejecuta el código de forma síncrona (en el mismo hilo), al igual que una llamada a método normal.

Answer 9

Si desea ejecutar los contenidos de run () como lo haría con cualquier otro método. No para comenzar un hilo, por supuesto.

Answer 10

Si la pregunta fue: "por qué se llama al método de inicio de subproceso en lugar de ejecutar el método directamente", entonces he respondido con un código de ejemplo a continuación. Espero que eso aclare. En el ejemplo a continuación:

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

Answer 11

Solo una nota sobre los excelentes comentarios anteriores: a veces escribes un código multihilo que usa el método "start" para ejecutar diferentes hilos. Le resultará mucho más fácil si utiliza "ejecutar" (en lugar de "iniciar") para la depuración, ya que hace que el código se ejecute de forma sincrónica y la depuración sea mucho más fácil.

Answer 12

Suponiendo que conoce el uso del método de inicio y ejecución, es decir, sincrónico vs. asincrónico; El método run se puede usar solo para probar la funcionalidad.

Además, en algunas circunstancias, la misma clase de subprocesos se puede usar en dos lugares diferentes con requisitos de funcionalidad de sincronización y asincronización al tener dos objetos diferentes con el método de ejecución de uno y el método de inicio de otros que se invocan.

Answer 13

Tomado de las preguntas frecuentes de los hilos de Java del estilo del código :

P: ¿Cuál es la diferencia entre los métodos start () y run () de un subproceso?

R: Los métodos separados start () y run () en la clase Thread proporcionan dos formas de crear programas enhebrados. El método start () inicia la ejecución del nuevo hilo y llama al método run (). El método start () regresa inmediatamente y el nuevo subproceso normalmente continúa hasta que el método run () retorna.

El método run () de la clase Thread no hace nada, por lo que las subclases deben anular el método con código para ejecutar en el segundo hilo. Si se crea una instancia de un subproceso con un argumento ejecutable, el método run () del subproceso ejecuta el método run () del objeto ejecutable en el nuevo subproceso en su lugar.

Dependiendo de la naturaleza de su programa enhebrado, llamar directamente al método Thread run () puede dar el mismo resultado que llamar mediante el método start (), pero en este último caso el código se ejecuta realmente en un nuevo hilo.

Answer 14

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