Java實現非同步的幾種方法

一、非同步概念

Java是一門面向對象編程語言，對於一個對象或一個方法，如果它需要執行一個比較長的操作可能會阻塞程序，導致程序變慢，用戶體驗不好。這時我們就需要將這個操作放到另一個線程中去執行，讓主程序繼續執行下面的邏輯代碼，這樣就可以實現多線程非同步執行。非同步執行是一種對資源佔用率比較低，提高程序運行效率的方式。

二、Future 非同步

Future 是 Java 中並發包里的一個類，可以用來實現非同步回調。Future 的特點是，執行 Future.get() 方法時，如果非同步操作已經完成，就直接返回結果；如果非同步操作沒有完成，那麼它會等待操作完成再返回結果。

import java.util.concurrent.*;

public class FutureDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        
        Future future = threadPool.submit(() -> {
            // 模擬非同步操作
            Thread.sleep(1000);
            return 100;
        });
        
        Integer result = future.get();
        
        System.out.println(result);
        
        threadPool.shutdown();
    }
}

三、CompletableFuture 非同步

CompletableFuture 是 Java 8 中新增的非同步操作類，是對 Future 的增強，支持非同步回調、回滾、組合等操作。它的非同步任務可以自由地與其他任務組合執行。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    public static void main(String[] args) throws Exception {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            // 模擬非同步操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 100;
        });
        
        future.thenAccept((result) -> {
            System.out.println(result);
        });
        
        // 阻塞等待非同步任務執行完成
        future.join();
    }
}

四、回調函數 Callback

回調函數是指我們預先定義一個方法，然後將這個方法傳給非同步任務執行，非同步任務執行完成後再執行我們預先定義好的回調方法。

public class CallbackDemo {
    public static void main(String[] args) throws Exception {
        asyncMethod((result) -> {
            System.out.println(result);
        });
        
        System.out.println("Main Thread End...");
    }
    
    private static void asyncMethod(Callback callback) {
        new Thread(() -> {
            // 模擬非同步操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            callback.onFinish(100);
        }).start();
    }
}

interface Callback {
    void onFinish(Integer result);
}

五、CompletableFuture 組合非同步

CompletableFuture 可以與其他 CompletableFuture 對象進行組合非同步操作，實現更加複雜的非同步操作。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureComposeDemo {
    public static void main(String[] args) throws Exception {
        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            // 模擬非同步操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 100;
        });
        
        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
            // 模擬非同步操作
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello";
        });
        
        CompletableFuture future3 = future1.thenCompose((result) -> {
            return CompletableFuture.supplyAsync(() -> {
                return result + " World";
            });
        });
        
        CompletableFuture future4 = future2.thenCombine(future3, (result1, result2) -> {
            return result1 + " " + result2;
        });
        
        future4.thenAccept((result) -> {
            System.out.println(result);
        });
        
        future4.join();
    }
}