So optimieren Sie die Leistung von asynchronen Java-Multithread-Aufrufen

Übersicht

Die Zahlungsaggregationsdienste großer E-Commerce-Unternehmen haben alle diese Art von Szenario:

• Aufrufen des Verifizierungsdienstes, um zu überprüfen, ob die zu generierende Bestellung legal ist

• Die Der Bestelldienst generiert die Bestellung (Der Verifizierungsdienst und der Bestelldienst haben keine Abhängigkeit)

• Aufruf 1 und 2, der Zahlungsdienst implementiert die Zahlungskernfunktion

• Kombiniert mit den Schritten 1 bis 3, um den Aggregationsaufruf von abzuschließen Der Zahlungsdienst

Wenn der Verbrauch von Schritt 1 5 Sekunden dauert, dauert Schritt 2 3 Sekunden und Schritt 3 dauert 2 Sekunden. Wenn Sie ein Architekt sind, gelten folgende Anforderungen:

1 Microservices

2. Bitte implementieren Sie asynchrone Aufrufe von Microservices (Implementiert mit CompletableFuture).

1. Führen Sie zwei asynchrone Berechnungen zu einer zusammen (die zweite asynchrone Berechnung hängt vom Ergebnis der ersten ab). mit Zukunft.

2. Warten Sie, bis alle Aufgaben in der Zukunftssammlung abgeschlossen sind. Warten Sie nur, bis die am schnellsten abgeschlossene Aufgabe in der Zukunftssammlung abgeschlossen ist, und geben Sie ihr Ergebnis zurück. Code-Adresse: 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");
    }
}

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;
    }
}

Nach dem Login kopieren

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;
    }
}

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;
    }
}

Das obige ist der detaillierte Inhalt vonSo optimieren Sie die Leistung von asynchronen Java-Multithread-Aufrufen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!