Resumen de conceptos básicos de Java (87) -Análisis de los principios de implementación invocables

Prefacio

En general, hay dos formas de crear subprocesos que usamos comúnmente:

Heredar hilo, reescribir el método de ejecución
Implementar la interfaz Runnable, volver a ejecutar el método

De hecho, existe otra forma de lograr la asincrónica en el marco Executor, que es implementar la interfaz invocable y reescribir el método de llamada. Aunque implementa Callable, cuando el Executor se está ejecutando, las instancias de Runnable o Callable se convertirán en instancias de RunnableFuture, y RunnableFuture hereda las interfaces Runnable y Future, que se explicarán en detalle a continuación. Sabiendo esto, ¿en qué se diferencia de Runnable? Invocable es diferente de Runnable en los dos puntos siguientes:

Invocable puede proporcionar un valor de retorno al final de la tarea, Runnable no puede proporcionar esta función
El método de llamada invocable puede generar excepciones, mientras que el método de ejecución de Runnable no puede generar excepciones.

Principio de realización

Antes de presentar el principio de implementación de Callable, echemos un vistazo a cómo se usa:

    public class ThreadTest {

        public static void main(String[] args) {
            System.out.println("main start");
            ExecutorService threadPool = Executors.newSingleThreadExecutor();
            // Future<?> future = threadPool.submit(new MyRunnable()) ;
            Future<String> future = threadPool.submit(new MyCallable());
            try {
                // 这里会发生阻塞
                System.out.println(future.get());
            } catch (Exception e) {

            } finally {
                threadPool.shutdown();
            }
            System.out.println("main end");
        }
    }


    public class MyCallable implements Callable<String> {

        @Override
        public String call() throws Exception {
            // 模拟耗时任务
            Thread.sleep(3000);
            System.out.println("MyCallable 线程：" + Thread.currentThread().getName());
            return "MyCallable" ;
        }
    }

    public class MyRunnable implements Runnable {

        @Override
        public void run() {
            // 模拟耗时任务
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("MyRunnable");
        }
    }

Ejecute el código anterior y obtendrá los siguientes resultados:

main start
// 这里会阻塞一段时间，才会打印下面的内容
MyCallable 线程：pool-1-thread-1
MyCallable
main end

A través del código anterior, hemos verificado la diferencia entre Callable y Runnable, entonces, ¿cómo se implementa Callable? Primero, pasamos la clase de implementación Callable MyCallable a ExecutorService.submit () y ExecutorService es una interfaz, por lo que debe anular el método submit () en su clase de implementación; seguimiento: Executors.newSingleThreadExecutor ()