异步设计实现

异步设计实现

异步设计是一种编程模式或方法，用于处理任务或操作，使其在不阻塞主线程或程序执行的情况下进行。在异步设计中，任务可以在后台或其他线程中执行，而不需要等待其完成。异步设计背后的核心思想是将耗时的操作或需要等待外部资源的操作（如网络请求、文件读取、数据库查询等）与程序的其他部分分离开来，使程序可以在执行这些操作的同时继续执行其他任务，提高了系统的响应性和性能。常见的异步设计方式包括：

1. 回调（Callback）：定义一个函数或代码块，在异步任务完成时被调用，用于处理结果或触发后续操作。

2. Promise/Future：表示一个可能尚未完成的操作，可以在其完成时获取结果。Promise通常用于处理单个异步操作，而Future是Java中表示异步计算结果的接口。

3. 事件驱动编程：基于事件和事件处理器的机制，当事件发生时，执行相应的处理逻辑。常见的例子包括GUI编程和各种框架中的事件驱动模型。

4. 异步函数/方法：使用关键字或标记来标识一个函数或方法是异步的，在执行时不会阻塞调用者

1.回调 Callbacks

1. 接口Fetcher

   public interface Fetcher {
       void fetchData(FetcherCallback callback);
   }
   

2. 回调事件 FetcherCallback

    public interface FetcherCallback {
        void onData(Data data) throws Exception;
        void onError(Throwable cause);
    }
   

3. MyFetcher继承Fetcher

    public class MyFetcher implements Fetcher {
   
        private Data data;
   
   	public MyFetcher(Data data) {
    	   this.data = data;
   	}
   
       @Override
       public void fetchData(FetcherCallback callback) {
        if (data == null) {
            callback.onError(new Exception("Data is null"));
            return;
        }
        try {
            callback.onData(data);
        } catch (Exception e) {
            callback.onError(e);
        }
      }
    }
   

4. Worker类

public class Worker {
    public void dowork() {
        Fetcher fetcher = new MyFetcher(new Data("testTitle", "Content..."));
        fetcher.fetchData(new FetcherCallback() {
            @Override
            public void onData(Data data) throws Exception {
                System.out.println("Data received: " + data);
            }

            @Override
            public void onError(Throwable cause) {
                System.out.println("An error accour: " + cause.getMessage());
            }
        });
    }

    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.dowork();
    }

5. Data类

public class Data {
	private String title;
	private String content;

	public Data(String title, String content) {
		this.title = title;
		this.content = content;
	}

	@Override
	public String toString() {
		return "Data:["+title + ":" + content + "]";
	}
}

2. Future

Futures是一个抽象的概念，它表示一个值，该值可能在某一点变得可用。一个Future要么获得计算完的结果，要么获得计算失败后的异常.Java在java.util.concurrent包中附带了Future接口.它使用Executor异步执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AsyncExample {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        executor.submit(() -> {
            // 执行异步任务
            String result = performAsyncTask();
            
            // 异步任务完成后的回调函数
            callback(result);
        });

        executor.shutdown();
    }

    public static String performAsyncTask() {
        // 执行异步任务的代码
        return "Async task result";
    }

    public static void callback(String result) {
        // 处理异步任务完成后的结果
        System.out.println("Async task completed with result: " + result);
    }
}

Java 8引入的CompletableFuture

• CompletableFuture是Java 8引入的一个类，用于支持异步编程。

• 它提供了丰富的方法来处理异步操作的完成和组合

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {

    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 执行异步任务
            return performAsyncTask();
        });

        future.thenAccept(result -> {
            // 处理异步任务完成后的结果
            System.out.println("Async task completed with result: " + result);
        });
    }

    public static String performAsyncTask() {
        // 执行异步任务的代码
        return "Async task result";
    }
}