java - ejemplos - ¿Cómo usar Callable con void return type?

list callable java

Question

Estoy trabajando en un proyecto en el que tengo varias interfaces y dos clases de Implementaciones que necesitan implementar estas dos interfaces.

Supongamos que mi primera interfaz es -

public Interface interfaceA {
public void abc() throws Exception;
}

Y su implementación es -

public class TestA implements interfaceA {
// abc method
}

Lo estoy llamando así.

TestA testA = new TestA();
testA.abc();

Ahora mi segunda interfaz es -

public Interface interfaceB {
public void xyz() throws Exception;
}

Y su implementación es -

public class TestB implements interfaceB {
// xyz method
}

Lo estoy llamando así.

TestB testB = new TestB();
testB.xyz();

Planteamiento del problema:-

Ahora mi pregunta es: ¿hay alguna manera, puedo ejecutar estas dos clases de implementación en paralelo? No quiero ejecutarlo en secuencia.

Es decir, quiero ejecutar la implementación de TestA y TestB en paralelo? ¿Es posible hacerlo?

Estaba pensando en usar Callable aquí, pero no estoy seguro de cómo usar Callable con el tipo void return aquí.

Usemos la clase TestB como ejemplo:

public interface interfaceB {
public void xyz() throws Exception;
}
public class TestB implements interfaceB, Callable<?>{
@Override
public void xyz() throws Exception
{
//do something
}
@Override
public void call() throws Exception
{
xyz();
}
}

El código de arriba da error de compilación ...

ACTUALIZAR:-

Parece que mucha gente está sugiriendo usar Runnable en lugar de llamable. Pero no estoy seguro de cómo uso Runnable aquí para poder ejecutar TestA and TestB en paralelo.

Answer 1

¿Por qué necesitarías un vacío para ejecutar algo en paralelo? Por un lado, si no necesita el valor de retorno, simplemente puede devolver null .

Para hacer algo paralelo necesitas usar hilos / programación. Personalmente recomendaría evitar Callables, y usar Runnables en su lugar (y bueno, sin valor de retorno).

Answer 2

Puede utilizar java.lang.Thread para ejecución paralela. Sin embargo, en la mayoría de los casos es más fácil usar un java.util.concurrent.ExecutorService . El último proporciona un método para enviar un Callable y devuelve un Future para obtener el resultado más tarde (o esperar a que se complete).

Si testA.abc () y testB.xyz () se ejecutan en paralelo, utiliza el ExecutorService para ejecutar el primero en un subproceso separado mientras que el último se ejecuta en el subproceso original. Luego esperas la finalización de la primera para la sincronización.

ExecutorService executor = ... // e.g. Executors.newFixedThreadPool(4);
Future<Void> future = executor.submit(new Callable<Void>() {
public Void call() throws Exception {
testA.abc();
return null;
}
});
testB.xyz();
future.get(); // wait for completion of testA.abc()