Tascalate Async/Await 使用教程

姬珊慧Beneficient

于 2024-08-30 09:18:44 发布

阅读量281

点赞数 3

本文链接：https://blog.csdn.net/gitblog_01031/article/details/141705117

版权

Tascalate Async/Await 使用教程

tascalate-async-awaitAsync / Await asynchronous programming model for Java version 1.8 though 17; similar to the functionality available in C# 5. The implementation is based on continuations for Java (see my other projects).项目地址:https://gitcode.com/gh_mirrors/ta/tascalate-async-await

项目介绍

Tascalate Async/Await 是一个用于 Java 的异步编程模型，类似于 C# 5 中提供的功能。该项目基于 Java 的延续（continuations）实现，旨在简化异步编程的复杂性，提高代码的可读性和维护性。

项目快速启动

环境准备

确保你已经安装了 Java 8 或更高版本，并且配置了 Maven 环境。

添加依赖

在你的 build.gradle 文件中添加以下依赖：

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'net.tascalate.async:net.tascalate.async.tools.gradle:1.2.7'
        classpath 'net.tascalate.javaflow:net.tascalate.javaflow.tools.gradle:2.7.6'
    }
}

apply plugin: "java"
apply plugin: "async-await"
apply plugin: "continuations"

repositories {
    mavenCentral()
}

dependencies {
    implementation 'net.tascalate.async:net.tascalate.async.runtime:1.2.7'
    implementation 'net.tascalate.async:net.tascalate.async.extras:1.2.7'
    implementation 'net.tascalate:net.tascalate.promise:1.2.7'
}

编写异步代码

以下是一个简单的示例，展示了如何使用 Tascalate Async/Await 编写异步代码：

import static net.tascalate.async.CallСontext.async;
import static net.tascalate.async.CallСontext.await;
import net.tascalate.async.async;
import net.tascalate.async.suspendable;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyClass {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        MyClass myClass = new MyClass();
        myClass.mergeStrings().thenAccept(System.out::println);
        executor.shutdown();
    }

    @async
    public CompletionStage<String> mergeStrings() {
        StringBuilder result = new StringBuilder();
        for (int i = 1; i <= 10; i++) {
            String v = decorateStrings(i, "async ", " awaited");
            result.append(v).append('\n');
        }
        return async(result.toString());
    }

    @suspendable
    private String decorateStrings(int i, String prefix, String suffix) {
        return prefix + i + suffix;
    }
}

应用案例和最佳实践

避免“异步/等待地狱”

在编写异步代码时，应避免“异步/等待地狱”，即过度嵌套的异步调用。可以通过合理划分代码块，确保哪些部分可以并行执行，哪些部分需要串行执行。

public @async CompletionStage<Long> calculateTotalPrice(Order order) {
    Long rawItemsPrice = await(calculateRawItemsPrice(order));
    Long shippingCost = await(calculateShippingCost(order));
    Long taxes = await(calculateTaxes(order));
    return async(rawItemsPrice + shippingCost + taxes);
}

protected @async CompletionStage<Long> calculateRawItemsPrice(Order order) {
    // 计算原始商品价格
}

protected @async CompletionStage<Long> calculateShippingCost(Order order) {
    // 计算运费
}

protected @async CompletionStage<Long> calculateTaxes(Order order) {
    // 计算税费
}