Erstens die grundlegende Methode zur Realisierung von asynchron
1. Grundkenntnisse in Java-Multithreading
1) Thread erben
2) Implementieren Sie die Runnable-Schnittstelle
3) Implementieren Sie die Callable-Schnittstelle + FutureTask (erhalten Sie das zurückgegebene Ergebnis und behandeln Sie die Ausnahme)
4) Thread-Pool
einfaches Beispiel
public static class Thread01 extends Thread{
@Override
public void run(){
System.out.println("当前线程"+Thread.currentThread().getId());
int i = 10 / 2;
System.out.println("运行结果"+i);
}
}
public static class Callable01 implements Callable<Integer> {
@Override
public Integer call(){
System.out.println("当前线程"+Thread.currentThread().getId());
int i = 10 / 2;
System.out.println("运行结果"+i);
return i;
}
}
@Test
public void thread() throws ExecutionException, InterruptedException {
System.out.println("main --- start");
System.out.println("当前线程"+Thread.currentThread().getId());
// 继承thread开启一个线程
// Thread01 thread01 = new Thread01();
// thread01.start();
// ======第三种方式
Callable01 callable01 = new Callable01();
FutureTask<Integer> integerFutureTask = new FutureTask<>(callable01);
new Thread(integerFutureTask).start();
//等待整个线程执行完成 获取返回结果
//Integer integer = integerFutureTask.get();
System.out.println("main --- end ");
}
2. js asynchrone Grundlagen
2.1 Zunächst einmal ist die Ausführungsumgebung der Javascript-Sprache „single-threaded“. Das heißt, es kann immer nur eine Aufgabe gleichzeitig erledigt werden. Wenn es mehrere Aufgaben gibt, müssen sie in die Warteschlange gestellt werden, die vorherige Aufgabe wird abgeschlossen und dann wird die nächste Aufgabe ausgeführt.
Der Schlüssel hier ist eine Aufgabenwarteschlange ,
Wenn eine asynchrone Aufgabe erscheint, wird sie zuerst in die Aufgabenwarteschlange eingereiht. Wenn die Aufgabe endet oder der Stapel leer ist, kehrt die Aufgabe zum Hauptthread zurück. Somit erreicht ein einzelner Thread Asynchronität.
2.2 Code-Implementierung
Methode 1: setTimeout verwenden
Methode 2: natives asynchrones Ajax verwenden
Methode 3: Promise verwenden
Promise ist eine Lösung für asynchrone Programmierung, die vernünftiger und leistungsfähiger ist als herkömmliche Lösungen – Callback-Funktionen und Ereignisse. Es wurde zuerst von der Community vorgeschlagen und implementiert, ES6 hat es in den Sprachstandard geschrieben, die Verwendung vereinheitlicht und Promise-Objekte nativ bereitgestellt.
var promise = new Promise(function(resolve, reject){
// ... some code
if (/* 异步操作成功 */) {
resolve(value);
} else {
reject(error);
}
})
Nachdem die Promise-Instanz generiert wurde, kann die then-Methode verwendet werden, um jeweils zwei State-Callback-Parameter anzugeben. Die then-Methode kann zwei Callback-Funktionen als Parameter akzeptieren: Wird aufgerufen
, wenn der Status des Promise-Objekts in Resolved geändert wird (erforderlich).
Wird aufgerufen, wenn der Status des Promise-Objekts in Rejected geändert wird (optional).
Methode 4: async await
schreibt asynchronen Code mit synchroner Semantik , leichter verständlich
Zweitens: die Verwendung von CompletableFuture
2.1 Erstellen Sie eine asynchrone Operation
public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)
Die runAsync-Methode unterstützt keine Rückgabewerte.
supplyAsync kann den Rückgabewert unterstützen.
2.2 dann Verbrauchsverarbeitungsergebnis akzeptieren
public CompletionStage<Void> thenAccept(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor);
Die Nutzung von CompletableFuture bezieht sich auf https://www.jianshu.com/p/6bac52527ca4
3. Beschreibung von Nutzungsszenarien
3.1 Wenn mehrere Java-Abfragevorgänge Zeit in Anspruch nehmen, können Sie die asynchrone Orchestrierung wählen
Code zeigen wie unten
/**
* 查询页面详细内容
*/
@Override
public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
SkuItemVo skuItemVo = new SkuItemVo();
CompletableFuture<SkuInfoEntity> infoFutrue = CompletableFuture.supplyAsync(() -> {
//1 sku基本信息
SkuInfoEntity info = getById(skuId);
skuItemVo.setInfo(info);
return info;
}, executor);
CompletableFuture<Void> saleAttrFuture =infoFutrue.thenAcceptAsync(res -> {
//2 获取spu销售属性组合
List<ItemSaleAttrVo> saleAttrVos = skuSaleAttrValueService.getSaleAttrsBuSpuId(res.getSpuId());
skuItemVo.setSaleAttr(saleAttrVos);
},executor);
CompletableFuture<Void> descFuture = infoFutrue.thenAcceptAsync(res -> {
//3 获取spu介绍
SpuInfoDescEntity spuInfo = spuInfoDescService.getById(res.getSpuId());
skuItemVo.setDesc(spuInfo);
},executor);
// 等待所有任务都完成再返回
CompletableFuture.allOf(ImgageFuture,saleAttrFuture,descFuture).get();
return skuItemVo;
}
descFuture und saleAttrFuture werden asynchron ausgeführt, nachdem das Ergebnis von infoFutrue abgerufen wurde, um die asynchrone Anordnung abzuschließen;
3.2 js asynchrones Anwendungsbeispiel
Der js-Aspekt verwendet die meisten Ajax-Anforderungsdaten asynchron;
// 初始获取数据
async getFirstData() {
try {
const params = {
};
const data = await this.getTasks(params);
} catch (error) {
console.log(error);
}
},
Eine Kombination aus async und await;