ejemplos - list callable java

La diferencia entre las interfaces Runnable y Callable en Java (12)

¿Cuál es la diferencia entre usar las interfaces Runnable y Callable al diseñar un subproceso concurrente en Java, por qué elegiría una sobre la otra?

Cuáles son las diferencias en las aplicaciones de Runnable y Callable . ¿Es la diferencia solo con el parámetro de retorno presente en Callable ?

Básicamente sí. Vea las respuestas a esta pregunta . Y el javadoc para Callable .

¿Cuál es la necesidad de tener ambos si Callable puede hacer todo lo que Runnable hace?

¡Porque la interfaz Runnable no puede hacer todo lo que Callable hace!

Runnable ha existido desde Java 1.0, pero Callable solo se introdujo en Java 1.5 ... para manejar casos de uso que Runnable no admite. En teoría, el equipo de Java podría haber cambiado la firma del método Runnable.run() , pero esto habría roto la compatibilidad binaria con el código anterior a 1.5, lo que requeriría la recodificación al migrar el código Java antiguo a las JVM más nuevas. Eso es un GRAN NO-NO. Java se esfuerza por ser compatible con versiones anteriores ... y ese ha sido uno de los principales puntos de venta de Java para la informática empresarial.

Y, obviamente, hay casos de uso donde una tarea no necesita devolver un resultado o lanzar una excepción marcada. Para esos casos de uso, usar Runnable es más conciso que usar Callable<Void> y devolver un valor ficticio ( null ) desde el método call() .

Callable y Runnable ambos son similares entre sí y pueden usarse en la implementación de subprocesos. En el caso de implementar Runnable , debe implementar el método run () , pero en el caso de que se pueda llamar, debe implementar el método call () , ambos métodos funcionan de manera similar, pero el método call () tiene más flexibilidad. Hay algunas diferencias entre ellos.

Diferencia entre Runnable y callable como abajo--

1) El método run () de runnable devuelve vacío , significa que si desea que su hilo devuelva algo que pueda usar más, entonces no tiene otra opción con el método Runnable run () . Hay una solución ''Callable'' . Si desea devolver algo en forma de objeto , debe usar Callable en lugar de Runnable . La interfaz invocable tiene el método ''call ()'' que devuelve Object .

Método de firma - Ejecutable->

public void run(){}

Callable->

public Object call(){}

2) En el caso del método Runnable Run () , si surge alguna excepción verificada, debe manipularse con el bloque try catch , pero en el caso del método Callable call () puede lanzar la excepción marcada como se muestra a continuación.

public Object call() throws Exception {}

3) Runnable viene de la versión de java 1.0 heredada, pero se puede llamar en la versión de Java 1.5 con el marco Executer .

Si está familiarizado con los Ejecutores, entonces debería usar Callable en lugar de Runnable .

Espero que entiendas.

Como ya se mencionó aquí, Callable es una interfaz relativamente nueva y se introdujo como parte del paquete de concurrencia. Tanto Callable como Runnable se pueden usar con ejecutores. Class Thread (que implementa el propio Runnable) solo es compatible con Runnable.

Aún puedes usar Runnable con ejecutores. La ventaja de Callable es que puede enviarlo al ejecutor y obtener de inmediato el resultado futuro que se actualizará cuando finalice la ejecución. Lo mismo se puede implementar con Runnable, pero en este caso, debe administrar los resultados usted mismo. Por ejemplo, puede crear una cola de resultados que contendrá todos los resultados. Otro hilo puede esperar en esta cola y lidiar con los resultados que llegan.

Encontré esto en otro blog que puede explicarlo un poco más estas differences :

Aunque ambas interfaces son implementadas por las clases que desean ejecutar en un hilo de ejecución diferente, pero hay pocas diferencias entre las dos interfaces que son:

Una Callable<V> recuperable devuelve un resultado del tipo V , mientras que una instancia Runnable no lo hace.
Una Callable<V> puede lanzar excepciones comprobadas, mientras que una instancia Runnable no puede

Los diseñadores de Java sintieron la necesidad de ampliar las capacidades de la interfaz Runnable , pero no querían afectar los usos de la interfaz Runnable y probablemente esa fue la razón por la que Callable por tener una interfaz separada llamada Callable en Java 1.5 que cambiando el Runnable ya existente.

Propósito de estas interfaces de la documentación de Oracle:

Runnable interfaz Runnable debe ser implementada por cualquier clase cuyas instancias estén destinadas a ser ejecutadas por un Thread . La clase debe definir un método de no argumentos llamado run .

Callable : una tarea que devuelve un resultado y puede lanzar una excepción. Los implementadores definen un solo método sin argumentos llamados call. La interfaz Callable es similar a Runnable , ya que ambas están diseñadas para clases cuyas instancias son potencialmente ejecutadas por otro hilo. Un Runnable , sin embargo, no devuelve un resultado y no puede lanzar una excepción marcada.

Otras diferencias:

Puede pasar Runnable para crear un Thread . Pero no se puede crear un nuevo subproceso pasando Callable como parámetro. Puede pasar Callable solo a instancias de ExecutorService .
Example:
public class HelloRunnable implements Runnable { public void run() { System.out.println("Hello from a thread!"); } public static void main(String args[]) { (new Thread(new HelloRunnable())).start(); } }
Usa Runnable para disparar y olvidar llamadas. Utilice Callable para verificar el resultado.
Callable se puede pasar al método Runnable diferencia de Runnable . Los métodos invokeAny e invokeAll realizan las formas más comúnmente útiles de ejecución masiva, ejecutando una colección de tareas y luego esperando al menos una, o todas, para completar
Diferencia trivial: nombre del método a implementar => run() para Runnable y call() para Callable .

Vea la explicación here .

La interfaz invocable es similar a Runnable, ya que ambas están diseñadas para clases cuyas instancias son potencialmente ejecutadas por otro hilo. Un Runnable, sin embargo, no devuelve un resultado y no puede lanzar una excepción marcada.

Veamos dónde se puede usar Runnable y Callable.

Runnable y Callable se ejecutan en un subproceso diferente que el subproceso de llamada. Pero Callable puede devolver un valor y Runnable no puede. Entonces, ¿dónde se aplica esto realmente?

Runnable : si tiene una tarea de fuego y olvido, use Runnable. Ponga su código dentro de un Runnable y cuando se llame al método run (), puede realizar su tarea. El hilo de llamada realmente no le importa cuando realiza su tarea.

Anulable : si está intentando recuperar un valor de una tarea, use Callable. Ahora se puede llamar por sí solo no hará el trabajo. Necesitará un Futuro que envuelva alrededor de su Callable y obtenga sus valores en future.get (). Aquí, el hilo de llamada se bloqueará hasta que el futuro regrese con resultados que a su vez están a la espera de que se ejecute el método call () de Callable.

Así que piense en una interfaz para una clase de destino en la que tenga definidos los métodos de enrutamiento ejecutables y recuperables. La clase que llama llamará aleatoriamente a sus métodos de interfaz sin saber cuál es Runnable y cuál es Callable. Los métodos Runnable se ejecutarán de forma asíncrona, hasta que se llame a un método Callable. Aquí se bloqueará el hilo de la clase que llama, ya que está recuperando valores de su clase objetivo.

NOTA: Dentro de su clase de destino, puede realizar las llamadas a Callable y Runnable en un ejecutor de un solo hilo, haciendo que este mecanismo sea similar a una cola de envío serial. Por lo tanto, siempre que la persona que llama llame a los métodos envueltos de Runnable, el subproceso de la llamada se ejecutará realmente rápido sin bloqueo. Tan pronto como llame a un método Callable envuelto en Futuro, deberá bloquear hasta que se ejecuten todos los demás elementos en cola. Solo entonces el método volverá con valores. Este es un mecanismo de sincronización.

Callable interfaz Callable declara el método call() y debe proporcionar los genéricos como el tipo de Object call () debe devolver:

public interface Callable<V> { /** * Computes a result, or throws an exception if unable to do so. * * @return computed result * @throws Exception if unable to compute a result */ V call() throws Exception; }

Runnable otro lado, Runnable es una interfaz que declara el método run() que se llama cuando creas un Thread con el runnable y llamas a start (). También puede llamar directamente a run (), pero eso solo ejecuta el método run () en el mismo hilo.

public interface Runnable { /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object''s * <code>run</code> method to be called in that separately executing * thread. * <p> * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see java.lang.Thread#run() */ public abstract void run(); }

Para resumir algunas diferencias notables son

Un objeto Runnable no devuelve un resultado, mientras que un objeto Callable devuelve un resultado.
Un objeto Runnable no puede lanzar una excepción marcada cuando un objeto Callable puede lanzar una excepción.
La interfaz Runnable ha existido desde Java 1.0, mientras que Callable solo se introdujo en Java 1.5.

Pocas similitudes incluyen

Las instancias de las clases que implementan interfaces Runnable o Callable son ejecutadas potencialmente por otro hilo.
La instancia de las interfaces Callable y Runnable puede ser ejecutada por ExecutorService a través del método submit ().
Ambas son interfaces funcionales y se pueden usar en expresiones Lambda desde Java8.

Los métodos en la interfaz ExecutorService son

<T> Future<T> submit(Callable<T> task); Future<?> submit(Runnable task); <T> Future<T> submit(Runnable task, T result);

Las diferencias entre Callable y Runnable son las siguientes:

Callable se introduce en JDK 5.0 pero Runnable se introduce en JDK 1.0
Callable tiene el método call () pero Runnable tiene el método run ().
Callable tiene un método de llamada que devuelve valor pero Runnable tiene un método de ejecución que no devuelve ningún valor.
el método de llamada puede lanzar una excepción marcada, pero el método de ejecución no puede lanzar una excepción marcada.
Se puede usar el método submit () para poner en la cola de tareas, pero Runnable usa el método execute () para poner en la cola de tareas.

interfaz pública Runnable: la interfaz Runnable debe ser implementada por cualquier clase cuyas instancias estén destinadas a ser ejecutadas por un hilo. La clase debe definir un método de no argumentos llamado run. Esta interfaz está diseñada para proporcionar un protocolo común para los objetos que desean ejecutar código mientras están activos. Por ejemplo, Runnable es implementado por la clase Thread. Estar activo simplemente significa que un hilo se ha iniciado y aún no se ha detenido.

Además, Runnable proporciona los medios para que una clase esté activa sin subclasificar Thread. Una clase que implementa Runnable puede ejecutarse sin subclasificar Thread creando una instancia de Thread y pasándose a sí misma como destino. En la mayoría de los casos, la interfaz de Runnable se debe usar si solo planea anular el método run () y no otros métodos Thread. Esto es importante porque las clases no deben clasificarse a menos que el programador intente modificar o mejorar el comportamiento fundamental de la clase.

Desde: JDK1.0

Interfaz pública Callable <V>:

Una tarea que devuelve un resultado y puede lanzar una excepción. Los implementadores definen un solo método sin argumentos llamados call. La interfaz invocable es similar a Runnable, ya que ambas están diseñadas para clases cuyas instancias son potencialmente ejecutadas por otro hilo. Un Runnable, sin embargo, no devuelve un resultado y no puede lanzar una excepción marcada.

La clase Executors contiene métodos de utilidad para convertir de otras formas comunes a clases invocables.

Desde: JDK 1.5

+-------------------------------------+--------------------------------------------------------------------------------------------------+ | Runnable | Callable<T> | +-------------------------------------+--------------------------------------------------------------------------------------------------+ | Introduced in Java 1.0 of java.lang | Introduced in Java 1.5 of java.util.concurrent library | | Runnable cannot be parametrized | Callable is a parametrized type whose type parameter indicates the return type of its run method | | Runnable has run() method | Callable has call() method | | Runnable.run() returns void | Callable.call() returns a value of Type T | | Can not throw Checked Exceptions | Can throw Checked Exceptions | +-------------------------------------+--------------------------------------------------------------------------------------------------+

Un Callable necesita implementar el método call() mientras que un Runnable necesita implementar el método run() .
Un Callable puede devolver un valor, pero un Runnable no puede.
Un Callable puede lanzar una excepción marcada, pero un Runnable no puede.
Un Callable puede usarse con los ExecutorService#invokeXXX(Collection<? extends Callable<T>> tasks) , pero no se puede Runnable un Runnable .
public interface Runnable { void run(); } public interface Callable<V> { V call() throws Exception; }