Comment optimiser les performances des appels asynchrones multithread Java

Aperçu

Les services d'agrégation de paiements des grandes entreprises de commerce électronique ont tous ce genre de scénario :

• Appel au service de vérification pour vérifier si la commande à générer est légale

• Le Le service de commande génère la commande (Le service de vérification et le service de commande n'ont aucune dépendance)

• Appel 1 et 2, le service de paiement implémente la fonction de base de paiement

• Combiné aux étapes 1 à 3 pour terminer l'appel d'agrégation de le service de paiement

Si la consommation de l'étape 1 Cela prend 5 secondes, l'étape 2 prend 3 secondes et l'étape 3 prend 2 secondes Si vous êtes architecte, les exigences sont :

Veuillez mettre en œuvre des appels synchrones de. microservices

2. Veuillez implémenter des appels asynchrones de microservices (implémentés à l'aide de CompletableFuture)

Comparez les performances de 1 et 2.

Appels synchrones et appels asynchrones

Diagramme de classes futur

Inconvénients de Avenir

Future exprime directement l'un des multiples résultats Future Les dépendances entre eux présentent certains défauts :

1 Fusionner deux calculs asynchrones en un seul (le deuxième calcul asynchrone dépend du résultat du premier). avec Future.

2. Attendez que toutes les tâches de la collection Future soient terminées

Attendez seulement que la tâche terminée la plus rapide de la collection Future se termine et renvoie son résultat

Code

Adresse du code

https://gitee. com/zjvngvn/mutil-thread

Test

public class Test {
    public static void main(String[] args) {
    	// 同步调用
        long start1 = System.currentTimeMillis();
        PaymentService.syncPay();
        System.out.println("同步支付耗时:" + (System.currentTimeMillis() - start1)+" ms");
        System.out.println("=========================");
        // 异步调用
        long start2 = System.currentTimeMillis();
        PaymentService.asyncPay();
        System.out.println("异步支付耗时:" + (System.currentTimeMillis() - start2)+" ms");
    }
}

PaymentService

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
public class PaymentService {
    /**
     * 异步支付的入口方法
     *
     * @return
     */
    public static boolean asyncPay() {
        //校验
        CompletableFuture<Boolean> isValid = CompletableFuture.supplyAsync(() -> CheckService.isValid());
        //创建订单
        CompletableFuture<Integer> orderSum = CompletableFuture.supplyAsync(() -> OrderService.createOrder());
        //支付
        CompletableFuture<Integer> money = CompletableFuture.supplyAsync(() -> basePay());
        // 上面三个都完成之后,再进行下面匿名内部类的代码
        CompletableFuture.allOf(isValid, orderSum, money)
                .thenRun(() -> System.out.println("完成异步支付"))
                .join();
        return true;
    }
    /**
     * 同步支付的入口方法
     *
     * @return
     */
    public static boolean syncPay() {
        CheckService.isValid();
        OrderService.createOrder();
        basePay();
        System.out.println("同步支付成功");
        //假设支付成功
        return true;
    }
    public static int basePay() {
        int money = 1000;
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("支付");
        //假设支付成功
        return money;
    }
}

CheckService

import java.util.concurrent.TimeUnit;
public class CheckService {
	/**
	 * 返回true说明订单流程才会往下走
	 */
    public static boolean isValid() {
        System.out.println("订单生成前，检验订单是否合法" );
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //假设订单合法，通过校验
        return true;
    }
}

OrderService

import java.util.concurrent.TimeUnit;
public class OrderService {
    public static int createOrder() {
        int orderSum=1;
        System.out.println("生成订单" );
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //假设订单数量为1
        return orderSum;
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!