SpringBoot implementa tareas asincrónicas

1. Asíncrono y síncrono

Asíncrono (asíncrono) es relativo a la sincronización (sincronización) Es sencillo entender que la sincronización es en serie y la asíncrona es paralela.

Por ejemplo, A necesita obtener datos de dos nodos B y C

En la primera forma, A solicita a B, B devuelve datos a A y A luego solicita a C que obtenga datos de C. De esta forma es la sincronización.

De otra manera, A pregunta a B, no espera a que B devuelva los datos, luego solicita C y luego espera a que B y C preparen los datos antes de enviarlos a A. A también puede obtener los datos de B y C. Esto es asincrónico.

Tenga en cuenta que el segundo método B y C procesan la solicitud de A al mismo tiempo, que es más eficiente que el primer método, pero este método tiene una limitación, es decir, los datos que se obtendrán de B y C no pueden ser Dependencia. Si C necesita los datos devueltos por B al obtener los datos de C, entonces el primer método solo se puede usar, primero solicitar B, obtener los datos de B y luego solicitar C.

Para dar un ejemplo más sencillo, resumen el pedido de alimentos en unos pocos pasos.

• 1. Realice un pedido, se ignora el tiempo.
• 2. Cocinar en el restaurante, 10 minutos.
• 3. Encuentra al hermano para llevar, 5 minutos. (Esto requiere una serie de algoritmos muy problemáticos para averiguar a qué hermanos notificar, esperar a que el hermano acepte la entrega y luego calcular el tiempo aproximado de llegada, asumiendo 5 minutos)
• 4. Entrega, 5 minutos.

Procesando en modo de sincronización, 1, 2, 3, 4 suman 20 minutos.

Sin embargo, no existe una relación estricta entre cocinar en el restaurante y encontrar un chico para llevar. 2 y 3 se pueden realizar al mismo tiempo, por lo que solo se necesitan 15 minutos para calcular.

 Asíncrono y síncrono son dos métodos de procesamiento. La sincronización es aplicable a muchos escenarios, y la codificación es simple y fácil de entender. Sin embargo, en algunos escenarios específicos, el asíncrono es mucho más eficiente que el síncrono.

2. Implementación de código, springboot usa tareas asincrónicas

1. Agregue la anotación @EnableAsync a la clase de inicio AsyncTaskApplication // habilite la función asincrónica

2. Implementar la clase de tarea e inyectarla en Spring

package com.frank;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.concurrent.Future;

/**
 * @author 小石潭记
 * @date 2020/6/29 20:52
 * @Description: ${todo}
 */
@Component
public class AsyncTask {

    @Async
    public Future<String> execTaskA() throws InterruptedException {
        System.out.println("TaskA开始");
        long star = new Date().getTime();
        Thread.sleep(5000);
        long end = new Date().getTime();
        System.out.println("TaskA结束，耗时毫秒数：" + (end - star));
        return new AsyncResult<>("TaskA结束");
    }

    @Async
    public Future<String> execTaskB() throws InterruptedException {
        System.out.println("TaskB开始");
        long star = new Date().getTime();
        Thread.sleep(3000);
        long end = new Date().getTime();
        System.out.println("TaskB结束，耗时毫秒数：" + (end - star));
        return new AsyncResult<>("TaskB结束");
    }

    @Async
    public Future<String> execTaskC() throws InterruptedException {
        System.out.println("TaskC开始");
        long star = new Date().getTime();
        Thread.sleep(4000);
        long end = new Date().getTime();
        System.out.println("TaskC结束，耗时毫秒数：" + (end - star));
        return new AsyncResult<>("TaskC结束");
    }
}

3. Utilice pruebas unitarias

package com.frank;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;
import java.util.concurrent.Future;

@SpringBootTest
class AsyncTaskApplicationTests {

    @Autowired
    AsyncTask asyncTask;

    @Test
    public void testAsyncTask() throws InterruptedException {
        long star = new Date().getTime();
        System.out.println("任务开始，当前时间" +star );
        Future<String> taskA = asyncTask.execTaskA();
        Future<String> taskB = asyncTask.execTaskB();
        Future<String> taskC = asyncTask.execTaskC();

        //间隔一秒轮询 直到 A B C 全部完成
        while (true) {
            if (taskA.isDone() && taskB.isDone() && taskC.isDone()) {
                break;
            }
            Thread.sleep(1000);
        }

        long end = new Date().getTime();
        System.out.println("任务结束，当前时间" + end);
        System.out.println("总耗时："+(end-star));
    }

}

A través de tareas asincrónicas, el tiempo total es de 6031 ms

Apague el comentario en la clase de inicio, pruebe, el tiempo total es 12003ms

En comparación, la asincronía lleva menos tiempo.

 

referencias