“Implementa Ejecutable” vs “se extiende hilo” en Java

Question

A partir de qué momento me he pasado con hilos en Java, he encontrado estas dos formas de escribir temas:

Con implements Runnable:

public class MyRunnable implements Runnable {
    public void run() {
        //Code
    }
}
//Started with a "new Thread(new MyRunnable()).start()" call

O, con extends Thread:

public class MyThread extends Thread {
    public MyThread() {
        super("MyThread");
    }
    public void run() {
        //Code
    }
}
//Started with a "new MyThread().start()" call

¿Hay alguna diferencia significativa en estos dos bloques de código?

Answer 1

Sí: implementa Runnable es la mejor forma de hacerlo, la OMI. Usted no está realmente especializada comportamiento del hilo. No eres más que lo que le da algo para funcionar. Eso significa composición es el filosóficamente forma "pura" para ir.

términos, esto significa que usted puede implementar Runnable y se extienden desde otra clase también.

Answer 2

tl; dr: implementa Ejecutable es mejor. Sin embargo, la advertencia es importante

En general, yo recomendaría usar algo así como Runnable en lugar de Thread ya que le permite mantener su obra sólo débilmente acoplados con su elección de concurrencia. Por ejemplo, si se utiliza un Runnable y decidir más adelante que este hecho no requieren su propio Thread, sólo puede llamar a threadA.run ().

Advertencia: Por aquí, Yo estoy totalmente en el uso de Temas primas. Me gusta mucho más el uso de callables y FutureTasks (del Javadoc: "Un cálculo asíncrono cancelables"). La integración de los tiempos de espera, cancelación adecuada y el conjunto de hilos de la ayuda de concurrencia moderna son todos mucho más útil para mí que montones de hilos primas.

Seguimiento: hay un FutureTask constructor que le permite utilizar Runnables (si eso es lo que usted se sienta más cómodo) y aún así obtener el beneficio de las herramientas modernas de concurrencia . Para citar el javadoc :

Si usted no necesita un resultado en particular, considerar el uso de construcciones de la forma:

Future<?> f = new FutureTask<Object>(runnable, null)

Por lo tanto, si reemplazamos su runnable con su threadA, obtenemos lo siguiente:

new FutureTask<Object>(threadA, null)

Otra opción que le permite estar más cerca de Runnables es un ThreadPoolExecutor . Puede utilizar el ejecutar método para pasar en un Ejecutable para ejecutar 'la tarea dada en algún momento en el futuro.'

Si desea probar el uso de un grupo de subprocesos, el fragmento de código anterior podría ser algo así como lo siguiente (utilizando el Executors.newCachedThreadPool () método de fábrica):

ExecutorService es = Executors.newCachedThreadPool();
es.execute(new ThreadA());

Answer 3

Moraleja de la historia:

heredan sólo si desea anular algún comportamiento.

sino que debe ser leído como

O:

Heredar menos, interfaz más.

Answer 4

Bien tantas buenas respuestas, quiero añadir más en esto. Esto ayudará a entender Extending v/s Implementing Thread.
Extiende une dos archivos de clase muy de cerca y puede causar algunos bastante difícil de tratar con el código.

Ambos enfoques tienen la misma función, pero ha habido algunas diferencias.
La diferencia más común es

1. Cuando se extiende clase Thread, después de que no se puede otorgar ninguna otra clase que usted requiere. (Como saben, Java no permite la herencia de más de una clase).
2. Cuando se implementa Ejecutable, se puede ahorrar espacio para su clase para otorgar ninguna otra clase en el futuro o ahora.

Sin embargo, un diferencia significativa entre la implementación Ejecutable y que se extiende de rosca es que
by extending Thread, each of your threads has a unique object associated with it, whereas implementing Runnable, many threads can share the same object instance.

El siguiente ejemplo ayudará a entender más claramente

//Implement Runnable Interface...
 class ImplementsRunnable implements Runnable {

private int counter = 0;

public void run() {
    counter++;
    System.out.println("ImplementsRunnable : Counter : " + counter);
 }
}

//Extend Thread class...
class ExtendsThread extends Thread {

private int counter = 0;

public void run() {
    counter++;
    System.out.println("ExtendsThread : Counter : " + counter);
 }
}

//Use the above classes here in main to understand the differences more clearly...
public class ThreadVsRunnable {

public static void main(String args[]) throws Exception {
    // Multiple threads share the same object.
    ImplementsRunnable rc = new ImplementsRunnable();
    Thread t1 = new Thread(rc);
    t1.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    Thread t2 = new Thread(rc);
    t2.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    Thread t3 = new Thread(rc);
    t3.start();

    // Creating new instance for every thread access.
    ExtendsThread tc1 = new ExtendsThread();
    tc1.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    ExtendsThread tc2 = new ExtendsThread();
    tc2.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    ExtendsThread tc3 = new ExtendsThread();
    tc3.start();
 }
}

salida del programa anterior.

ImplementsRunnable : Counter : 1
ImplementsRunnable : Counter : 2
ImplementsRunnable : Counter : 3
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1

En el enfoque de interfaz Ejecutable, se está creando una sola instancia de una clase y se ha compartido por diferentes hilos. Por lo que el valor del contador se incrementa para cada acceso de hilo.

Mientras, el enfoque de clase Thread, que debe tener para crear una instancia independiente para cada acceso hilo. Por lo tanto memoria diferente se asigna para cada instancias de clases y cada uno tiene contador separado, el valor sigue siendo igual, lo que significa que no hay incremento sucederá porque ninguno de la referencia de objeto es el mismo.

¿Cuándo utilizar Ejecutable?
Usar interfaz Ejecutable cuando se desea acceder a los mismos recursos del grupo de hilos. Evitar el uso de clase Thread aquí, porque la creación de varios objetos consume más memoria y se convierte en una gran sobrecarga de rendimiento.

Una clase que implementa Ejecutable no es un hilo y sólo una clase. Para un Ejecutable para convertirse en un hilo, es necesario crear una instancia de rosca y haciéndose pasar como el de destino.

En la mayoría de los casos, la interfaz Ejecutable debe usarse si sólo se está planeando reemplazar el método run() y no hay otros métodos hilo. Esto es importante porque las clases no deben tener subclases menos que el programador tiene la intención de modificar o mejorar el comportamiento fundamental de la clase.

Cuando hay una necesidad de extender una superclase, implementando la interfaz Ejecutable es más apropiado que el uso de la clase Thread. Debido a que podemos ampliar otra clase mientras se implementa la interfaz Ejecutable para hacer un hilo.

Espero que esto le ayudará!

Answer 5

Una cosa que me sorprende que no se ha mencionado todavía es que la implementación de Runnable hace que su clase más flexible.

Si se extiende el hilo entonces la acción que está haciendo siempre va a estar en un hilo. Sin embargo, si se implementa Runnable no tiene por qué ser. Se puede ejecutar en un hilo, o pasarlo a algún tipo de servicio ejecutor, o simplemente pasarlo alrededor como una tarea dentro de una única aplicación roscada (tal vez para ser ejecutado en un momento posterior, pero dentro del mismo hilo). Las opciones son mucho más abierto si sólo utiliza Runnable que si enlaza a sí mismo a Thread.

Answer 6

Si desea implementa o se extiende cualquier otra clase, entonces la interfaz Runnable es más preferible, de lo contrario, si no desea ninguna otra clase para extender o aplicar clase, entonces es preferible Thread.

La diferencia más común es

Cuando extends Thread clase, después de que no se puede otorgar ninguna otra clase que usted requiere. (Como saben, Java no permite la herencia de más de una clase).

Cuando implements Runnable, puede ahorrar espacio para su clase para otorgar ninguna otra clase en el futuro o ahora.

• Java no soporta herencia múltiple, lo que significa que sólo puede extender una clase en Java por lo que una vez que se extendió clase Thread que perdió su oportunidad y no se puede extender o heredar otra clase en Java.

• En la programación orientada a objetos, que se extiende una clase generalmente significa, añadiendo nueva funcionalidad, y modificar o mejorar los comportamientos. Si no estamos haciendo ninguna modificación en la rosca entonces utilice el interfaz Ejecutable en su lugar.

• interface Runnable representa una tarea que puede ser ejecutada por cualquiera de rosca o ejecutores liso o cualquier otro medio. la separación de manera lógica de tareas como Ejecutable el hilo es una buena decisión de diseño.

• La separación tarea como Ejecutable significa que podemos reutilizar la tarea y también tiene la libertad para ejecutarlo desde diferentes medios. ya que no puede reiniciar un hilo, una vez que se complete. Ejecutable de nuevo frente a rosca para la tarea, Ejecutable es ganador.

• diseñador de Java reconoce esto y es por eso que los ejecutores aceptar Ejecutable como tareas y tienen subproceso de trabajo que ejecuta los tarea.

• La herencia de todos los métodos de rosca se sobrecarga adicional simplemente para representar una tarea que se puede hacer fácilmente con Ejecutable.

Cortesía de javarevisited.blogspot.com

Estas fueron algunas de las diferencias notables entre rosca y Ejecutable en Java. Si conoces alguna otra diferencia en la rosca vs Ejecutable a favor compartirla a través de los comentarios. Yo personalmente uso Ejecutable sobre Hilo para este escenario y recomienda utilizar el interfaz Ejecutable o rescatable en base a sus necesidades.

Sin embargo, la diferencia es significativa.

Cuando extends Thread clase, cada uno de su hilo crea un objeto único y asociarse con él. Cuando implements Runnable, que comparte el mismo objeto de múltiples hilos.

Answer 7

En realidad, no es prudente comparar Runnable y Thread entre sí.

Esta dos tienen una relación de dependencia y en múltiples hilos al igual que la relación Wheel and Engine de vehículo de motor.

Yo diría, sólo hay un camino para múltiples hilos con dos pasos. Permítanme hacer mi punto.

Ejecutable:
Al implementar interface Runnable que significa que está creando algo que se run able en un hilo diferente. Ahora la creación de algo que puede funcionar dentro de un hilo (ejecutables dentro de una discusión), no significa que la creación de un hilo.
Por lo que el MyRunnable clase no es más que una clase ordinaria con un método void run. Y es objetos serán algunos de los objetos ordinarios con sólo una run método que se ejecutará normalmente cuando se le llama. (A menos que pasar el objeto en un hilo).

Tema:
class Thread, diría Una clase muy especial con la capacidad de iniciar un nuevo hilo que realmente permite múltiples hilos a través de su método de start().

¿Por qué no conveniente comparar?
Porque necesitamos a ambos por múltiples hilos.

Para multi-threading necesitamos dos cosas:

• Algo que puede funcionar dentro de una rosca (Ejecutable).
• algo que puede empezar un nuevo hilo (hilo).

Así que, técnicamente y, teóricamente, tanto de ellos es necesario iniciar un hilo, uno Ejecutar y un Hacer que funciona (como Wheel and Engine de vehículo de motor).

Es por eso que no se puede iniciar un hilo con MyRunnable lo necesario para pasar a una instancia de Thread.

Pero es posible crear y ejecutar un único hilo usando class Thread porque Thread clase implementa Runnable por lo que todos sabemos Thread también es un Runnable interior.

Por último Thread y Runnable se complementan entre sí para multithreading no competidor o reemplazo.

Answer 8

Debe implementar Ejecutable, pero si está ejecutando en Java 5 o superior, usted no debe comenzar con new Thread pero el uso de un ExecutorService su lugar. Para más detalles ver:. Cómo implementar rosca sencilla en Java

Answer 9

No soy un experto, pero puedo pensar en una razón para poner en práctica Ejecutable en lugar de extender la discusión:. Java sólo soporta herencia simple, por lo que sólo se puede extender una clase

Edit: Este principio dice "La implementación de una interfaz requiere menos recursos." así, pero es necesario crear una nueva instancia de rosca en ambos sentidos, por lo que esto estaba mal.

Answer 10

Yo diría que hay una tercera vía:

public class Something {

    public void justAnotherMethod() { ... }

}

new Thread(new Runnable() {
   public void run() {
    instanceOfSomething.justAnotherMethod();
   }
}).start();

Tal vez esto está influenciado un poco por mi reciente uso intensivo de Javascript y Actionscript 3, pero de esta manera su clase no tiene que implementar una interfaz bastante vagos como Runnable.

Answer 11

Con el lanzamiento de Java 8, ahora hay una tercera opción.

Runnable es un interfaz href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html#jls-9.8"> funcional, que significa que los casos de que se pueden crear con expresiones lambda o referencias de métodos.

Su ejemplo puede ser reemplazado con:

new Thread(() -> { /* Code here */ }).start()

o si desea utilizar una ExecutorService y una referencia método:

executor.execute(runner::run)

Estos no sólo son mucho más cortos que sus ejemplos, pero también vienen con muchas de las ventajas indicadas en otras respuestas de la utilización de Runnable sobre Thread, como única responsabilidad y el uso de la composición, ya que no está especializada comportamiento del hilo. De esta manera también se evita la creación de una clase extra si todo lo que necesita es un Runnable como lo hace en sus ejemplos.

Answer 12

Creación de una instancia de interfaz da una separación limpia entre su código y la aplicación de hilos, por lo que preferiría para implementar Ejecutable en este caso.

Answer 13

Aquí todo el mundo parece pensar que la implementación Ejecutable es el camino a seguir y realmente no están de acuerdo con ellos, pero también hay una posibilidad de extender rosca en mi opinión, en el hecho de que haya una especie de lo demostró en el código.

Si implementa Ejecutable entonces la clase que implementa Ejecutable no tiene control sobre el nombre del hilo, es el código de llamada que puede establecer el nombre del hilo, así:

new Thread(myRunnable,"WhateverNameiFeelLike");

pero si extiende hilo entonces se llega a manejar esta dentro de la clase en sí (al igual que en el ejemplo usted nombra el hilo 'ThreadB'). En este caso:

A) podría darle un nombre más útil para propósitos de depuración

B) están obligando a que ese nombre se utiliza para todas las instancias de esa clase (a menos que se ignora el hecho de que es un hilo y hacer lo anterior con él como si se trata de un Ejecutable, pero estamos hablando de convención aquí en cualquier caso por lo que puede pasar por alto esa posibilidad me siento).

Puede ser que incluso, por ejemplo, tener un seguimiento de pila de su creación y el uso que como su nombre hilo. Esto puede parecer extraño, pero dependiendo de cómo está estructurado el código que puede ser muy útil para propósitos de depuración.

Esto puede parecer algo pequeño, pero donde se tiene una aplicación muy complejo con una gran cantidad de hilos y, de repente las cosas 'han dejado' (ya sea por razones de estancamiento o, posiblemente debido a una falla en un protocolo de red que sería menos evidente - o por otras razones sin fin) a continuación, obtener un volcado de pila de Java, donde todos los temas son llamados 'Tema-1', 'Tema-2', 'Tema-3' no siempre es muy útil (que depende de cómo sus hilos están estructurados de manera útil y si se puede decir que es la que acaba por su seguimiento de la pila -. no siempre es posible si está utilizando grupos de múltiples hilos de todos los que ejecuta el mismo código)

Una vez dicho esto se podría, por supuesto también hacer lo anterior de una manera genérica mediante la creación de una extensión de la clase hilo que establece su nombre a un seguimiento de pila de su llamada de la creación y luego utilizar estos fondos con sus implementaciones Ejecutable en lugar de la norma clase java hilo (ver más abajo), pero además del seguimiento de la pila que podría haber más información específica contexto que sería útil en el nombre del hilo para la depuración (una referencia a una de las muchas colas o enchufes que podría procesamiento, por ejemplo, en cuyo caso se podrían preferir extender hilo en ese caso específico, para que pueda tener la fuerza compilador usted (u otros utilizando sus bibliotecas) para pasar de cierta información (por ejemplo, la cola / hembra en cuestión) para su uso en el nombre).

Este es un ejemplo de la rosca genérico con el seguimiento de pila llamar como su nombre:

public class DebuggableThread extends Thread {
    private static String getStackTrace(String name) {
        Throwable t= new Throwable("DebuggableThread-"+name);
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(os);
        t.printStackTrace(ps);
        return os.toString();
    }

    public DebuggableThread(String name) {
        super(getStackTrace(name));
    }

    public static void main(String[] args) throws Exception {
        System.out.println(new Thread());
        System.out.println(new DebuggableThread("MainTest"));
    }
}

y aquí es una muestra de la salida de la comparación de los dos nombres:

Thread[Thread-1,5,main]
Thread[java.lang.Throwable: DebuggableThread-MainTest
    at DebuggableThread.getStackTrace(DebuggableThread.java:6)
    at DebuggableThread.<init>(DebuggableThread.java:14)
    at DebuggableThread.main(DebuggableThread.java:19)
,5,main]

Answer 14

Ejecutable porque:

• deja más flexibilidad para el aplicación ejecutable para extender otra clase
• separación entre el código de ejecución
• le permite ejecutar su ejecutable a partir de un grupo de subprocesos, la hilo de eventos, o de cualquier otra manera en el futuro.

Incluso si usted no necesita nada de esto ahora, es posible que en el futuro. Dado que no hay ningún beneficio a rosca primordial, Ejecutable es una solución mejor.

Answer 15

Dado que este es un tema muy popular y las buenas respuestas están repartidos por todo y se ocupó en gran profundidad, sentí que es justificable para compilar las buenas respuestas de los otros en una forma más concisa, por lo que los recién llegados tienen una visión general fácil adelantado:

1. Por lo general, extender una clase para añadir o modificar la funcionalidad. Por lo tanto, si no desea a sobreescritura cualquier el comportamiento del hilo , a continuación, utilizar Ejecutable.

2. En la misma luz, si no es necesario a hereda métodos de rosca, se puede hacer sin que sobrecarga por usando Ejecutable.

3. Herencia simple . Si se extiende hilo no se puede extender desde cualquier otra clase, así que si eso es lo que hay que hacer, usted tiene que utilizar Ejecutable

4. Es un buen diseño de la lógica de dominio separado de los medios técnicos, en ese sentido, es mejor tener una tarea Ejecutable aislamiento tarea de corredor .

5. Puede Ejecutar el mismo Ejecutable Objeto varias veces , un objeto Thread, sin embargo, sólo puede comenzar una vez. (Tal vez la razón, ¿por qué los ejecutores aceptan Runnables, pero no Hilos.)

6. Si desarrolla su tarea como Ejecutable, tiene toda la flexibilidad cómo usarlo ahora y en el futuro . Puede hacer que se ejecute al mismo tiempo a través de los ejecutores, sino también a través del hilo. Y todavía se podría también utilizar / llamarlo no al mismo tiempo dentro del mismo hilo al igual que cualquier otro tipo ordinario / objeto.

7. Esto hace que sea también más fácil de separada tarea lógica y la concurrencia aspectos de sus pruebas unidad .

8. Si está interesado en esta cuestión, es posible que también está interesado en el diferencia entre Callable y Ejecutable .

Answer 16

Diferencia entre Extendiendo hilo e implementación Ejecutable son:

Answer 17

Esto se discute en Definir e iniciar un tutorial Tema :

  

¿Cuál de estas expresiones se debe utilizar? El primer idioma, que emplea una   objeto ejecutable, es más general, ya que el objeto ejecutable puede   subclase de una clase distinta de rosca. El segundo idioma es más fácil de usar   en aplicaciones simples, pero está limitado por el hecho de que su tarea   clase debe ser un descendiente de hilo. Esta lección se centra en la primera   enfoque, que separa la tarea Ejecutable desde el objeto Thread   que ejecuta la tarea. No sólo es este enfoque más flexible, pero   es aplicable a las API de gestión de hilo de alto nivel cubiertos   más tarde.

En otras palabras, la aplicación de Runnable trabajará en escenarios donde su clase extiende una clase distinta de Thread. Java no soporta herencia múltiple. También, se extiende Thread no será posible cuando se utilizan algunos de los API de gestión de hilo de alto nivel. El único escenario en el que es preferible que se extiende Thread está en una pequeña aplicación que no estará sujeto a actualizaciones en el futuro. Casi siempre es mejor implementar Runnable ya que es más flexible que su proyecto crezca. Un cambio de diseño no tendrá un impacto importante como se puede implementar muchas interfaces en Java, pero sólo extender una clase.

Answer 18

Si no estoy equivocado, que es más o menos similar a

¿Cuál es la diferencia entre una interfaz y clase abstracta?

extiende establece " es un " relación e interfaz proporciona " Tiene un " capacidad.

Prefiero implementa Ejecutable

1. Si usted no tiene que extender la clase Thread y modificar Tema implementación por defecto API
2. Si se está ejecutando un incendio y se olvida de comandos
3. Si ya está extendiendo otra clase

Prefiero " se extiende Tema ":

1. Si tiene que anular alguna de estas href="https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html" métodos que se enumeran en la página de documentación de Oracle

En general no es necesario para anular el comportamiento del hilo. Así implementa Ejecutable es el preferido para la mayoría de las veces.

En una nota diferente, usando ExecutorService avanzado o API ThreadPoolExecutorService proporciona más flexibilidad y control.

Tener un vistazo a esta pregunta SE:

ExecutorService vs informal Tema análisis reproductor

Answer 19

La explicación más simple sería mediante la implementación de Runnable podemos asignar el mismo objeto de múltiples hilos y cada Thread comparte los mismos estados y comportamiento del objeto.

Por ejemplo, supongamos que hay dos hilos, Thread1 pone un número entero en una matriz y thread2 toma números enteros de la matriz cuando la matriz se llena. Nótese que para que thread2 a trabajar que necesita para conocer el estado de la matriz, ya sea Thread1 ha llenado hacia arriba o no.

La implementación de Runnable le permite tener esta flexibilidad para compartir el objeto mientras que extends Thread hace que le permite crear nuevos objetos para cada uno de los hilos, por tanto, cualquier actualización que se realiza Thread1 se pierde a Thread2.

Answer 20

La separación de la clase Thread de la aplicación Ejecutable también evita posibles problemas de sincronización entre la el método run () de hilo y. A Ejecutable separada generalmente da una mayor flexibilidad en la forma en que el código ejecutable es referenciado y ejecutado.

Answer 21

Esa es la S de SOLID: la responsabilidad individual.

A hilo encarna la contexto corriendo (como en el contexto de ejecución: marco de pila, ID del tema, etc.) de la ejecución asíncrono de una pieza de código. Que pieza de código idealmente debería ser la misma aplicación, ya sea sincrónica o asíncrono .

Si agruparlos en una implementación, le das el objeto resultante de dos no relacionada causas del cambio:

1. manejo hilo en su aplicación (es decir. Consultar y modificar el contexto de ejecución)
2. algoritmo implementado por el fragmento de código (la parte ejecutable)

Si el lenguaje que utiliza es compatible con las clases parciales o herencia múltiple, entonces se puede separar cada causa en su propia superclase, pero se reduce a lo mismo que la composición de los dos objetos, ya que sus conjuntos de características no se superponen. Eso es para la teoría.

En la práctica, en términos generales, un programa no tiene por qué llevar a una mayor complejidad de lo necesario. Si usted tiene un hilo que trabaja en una tarea específica, sin tener que cambiar esa tarea, es probable que haya ninguna razón para hacer las tareas de clases separadas, y su código permanece más simple.

En el contexto de Java , ya que la instalación es ya existe , es probable que sea más fácil comenzar directamente con soporte clases Runnable por sí solos, y pasar sus instancias a Thread ( o Executor) instancias. Una vez utiliza a ese patrón, no es más difícil de usar (o incluso leer) que la simple caso hilo ejecutable.

Answer 22

Una de las razones que querría implementar una interfaz en lugar de extender una clase base es que ya está extendiendo alguna otra clase. Sólo se puede extender una clase, pero se puede implementar cualquier número de interfaces.

Si se extiende hilo, que está impidiendo básicamente su lógica para ser ejecutado por cualquier otro hilo que 'esto'. Si sólo desea algunos hilo para ejecutar su lógica, es mejor simplemente aplicar Ejecutable.

Answer 23

si utiliza ejecutable que puede ahorrar el espacio de aplicarse al de la otra clase.

Answer 24

¿Podemos volver a visitar la razón básica que queríamos nuestra clase a comportarse como un Thread? No hay ninguna razón en absoluto, sólo queríamos para ejecutar una tarea, lo más probable en un modo asíncrono, lo que significa, precisamente, que la ejecución de la tarea debe ramificarse desde nuestro hilo principal y el hilo principal, si termina temprano, pueden o no pueden esperar para la ruta ramificada (tarea).

Si esto es todo el propósito, entonces ¿dónde veo la necesidad de un hilo especializado. Esto se puede lograr al recoger un hilo RAW del grupo de subprocesos del sistema y asignándole nuestra tarea (puede ser una instancia de nuestra clase) y eso es todo.

Así Obedezcamos el concepto OOPs y escribir una clase del tipo que necesitamos. Hay muchas maneras de hacer las cosas, haciéndolo en la forma en que las cosas correctas.

Necesitamos una tarea, por lo que escribir una definición de la tarea que se puede ejecutar en un hilo. Así que utilice Ejecutable.

Recuerde siempre implements se utiliza especialmente para impartir un comportamiento y extends se utiliza para impartir una función / propiedad.

No queremos que la propiedad de la rosca, en lugar queremos que nuestra clase se comporte como una tarea que se puede ejecutar.

Answer 25

Sí, Si llama llamada ThreadA, entonces no necesite llamar al método start y el método de ejecución es llamada tras llamada sólo la clase ThreadA. Pero si el uso de la llamada ThreadB continuación, tendrá que sea necesario el hilo de inicio de llamada al método de ejecución. Si usted tiene más ayuda, responda yo.

Answer 26

Me parece que es más útil usar Ejecutable por todas las razones mencionadas, pero a veces me gustaría extender hilo para que pueda crear mi propio método de parada de hilo y llamarlo directamente sobre el hilo que he creado.

Answer 27

Java no soporta múltiples inheritence por lo que si se extiende clase Thread continuación, se extenderá ninguna otra clase.

Por ejemplo: si crea un applet entonces debe extiende clase Applet así que aquí la única manera de crear hilo está implementando la interfaz Ejecutable

Answer 28

Runnable es una interfaz, mientras que Thread es una clase que implementa esta interfaz. Desde el punto de vista del diseño, debe haber una separación limpia entre cómo se define una tarea y entre la forma en que se ejecuta. El primero es la responsabilidad de una aplicación Runnalbe, y éste es el trabajo de la clase Thread. En la mayoría de los casos de aplicación Runnable es el camino correcto a seguir.

Answer 29

Diferencia entre rosca y ejecutable .Si estamos creando hilo usando clase Thread continuación Número de hilo igual al número de objetos que hemos creado. Si estamos creando hilo implementando la interfaz ejecutable entonces podemos utilizar un solo objeto para la creación de múltiples thread.So único objeto es compartida por múltiples Thread.So se tardará menos memoria

Así que dependiendo de la exigencia si nuestros datos no es senstive. Por lo tanto, se puede compartir entre múltiples rosca podemos utilizado interface Runnable.

Answer 30

Adición de mis dos centavos aquí - Siempre siempre que sea posible el uso implements Runnable. A continuación se presentan dos advertencias sobre por qué no se debe utilizar extends Threads

1. Lo ideal sería que nunca se debe extender la clase Thread; la clase Thread debe hacerse final. Al menos sus métodos como thread.getId(). Ver esta discusión para un error relacionado con Threads extienden.

2. Los que les gusta resolver rompecabezas puede ver otro efecto secundario de la extensión del hilo. El código siguiente imprimirá código inalcanzable cuando nadie les está notificando.

Por favor, vea http://pastebin.com/BjKNNs2G .

public class WaitPuzzle {

    public static void main(String[] args) throws InterruptedException {
        DoNothing doNothing = new DoNothing();
        new WaitForever(doNothing).start();
        new WaitForever(doNothing).start();
        new WaitForever(doNothing).start();
        Thread.sleep(100);
        doNothing.start();
        while(true) {
            Thread.sleep(10);
        }
    }


    static class WaitForever extends  Thread {

        private DoNothing doNothing;

        public WaitForever(DoNothing doNothing) {
            this.doNothing =  doNothing;
        }

        @Override
        public void run() {
            synchronized (doNothing) {
                try {
                    doNothing.wait(); // will wait forever here as nobody notifies here
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Unreachable Code");
            }
        }
    }

    static class DoNothing extends Thread {

        @Override
        public void run() {
            System.out.println("Do Nothing ");
        }
    } 
}