異步加載緩存數據Java線程非阻塞優化

在Java中，異步加載緩存數據并實現線程非阻塞優化可以通過多種方式來實現。以下是一些常見的方法：

1. 使用CompletableFuture

CompletableFuture是Java 8引入的一個強大的異步編程工具，可以用來處理異步任務。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class AsyncCacheLoader {
    private final Cache<String, String> cache = new ConcurrentHashMap<>();

    public CompletableFuture<String> loadAsync(String key) {
        return CompletableFuture.supplyAsync(() -> {
            // 模擬從數據庫或其他數據源加載數據
            return fetchDataFromDataSource(key);
        });
    }

    public String get(String key) {
        return cache.computeIfAbsent(key, this::loadAsync)
                     .thenApply(CompletableFuture::join)
                     .orTimeout(10, TimeUnit.SECONDS)
                     .exceptionally(ex -> {
                         System.err.println("Error loading data for key: " + key);
                         return null;
                     });
    }

    private String fetchDataFromDataSource(String key) {
        // 模擬從數據庫或其他數據源加載數據
        try {
            Thread.sleep(1000); // 模擬耗時操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Data for key: " + key;
    }

    public static void main(String[] args) {
        AsyncCacheLoader cacheLoader = new AsyncCacheLoader();
        cacheLoader.get("key1").thenAccept(System.out::println);
    }
}

2. 使用ExecutorService

ExecutorService是一個線程池，可以用來執行異步任務。

import java.util.concurrent.*;

public class AsyncCacheLoader {
    private final Cache<String, String> cache = new ConcurrentHashMap<>();
    private final ExecutorService executorService = Executors.newFixedThreadPool(10);

    public Future<String> loadAsync(String key) {
        return executorService.submit(() -> {
            // 模擬從數據庫或其他數據源加載數據
            return fetchDataFromDataSource(key);
        });
    }

    public String get(String key) {
        return cache.computeIfAbsent(key, this::loadAsync)
                     .get();
    }

    private String fetchDataFromDataSource(String key) {
        // 模擬從數據庫或其他數據源加載數據
        try {
            Thread.sleep(1000); // 模擬耗時操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Data for key: " + key;
    }

    public static void main(String[] args) {
        AsyncCacheLoader cacheLoader = new AsyncCacheLoader();
        try {
            System.out.println(cacheLoader.get("key1"));
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            cacheLoader.executorService.shutdown();
        }
    }
}

3. 使用ConcurrentHashMap的computeIfAbsent方法

ConcurrentHashMap提供了computeIfAbsent方法，可以在緩存未命中時異步加載數據。

import java.util.concurrent.*;

public class AsyncCacheLoader {
    private final Cache<String, String> cache = new ConcurrentHashMap<>();
    private final ExecutorService executorService = Executors.newFixedThreadPool(10);

    public String get(String key) {
        return cache.computeIfAbsent(key, key -> {
            // 模擬從數據庫或其他數據源加載數據
            CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
                return fetchDataFromDataSource(key);
            }, executorService);

            future.thenApply(data -> {
                cache.put(key, data);
                return data;
            });

            return future;
        });
    }

    private String fetchDataFromDataSource(String key) {
        // 模擬從數據庫或其他數據源加載數據
        try {
            Thread.sleep(1000); // 模擬耗時操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Data for key: " + key;
    }

    public static void main(String[] args) {
        AsyncCacheLoader cacheLoader = new AsyncCacheLoader();
        System.out.println(cacheLoader.get("key1"));
    }
}

4. 使用ScheduledExecutorService進行定時刷新

如果需要定期刷新緩存數據，可以使用ScheduledExecutorService。

import java.util.concurrent.*;

public class AsyncCacheLoader {
    private final Cache<String, String> cache = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    public AsyncCacheLoader() {
        scheduler.scheduleAtFixedRate(this::refreshCache, 0, 5, TimeUnit.SECONDS);
    }

    public String get(String key) {
        return cache.get(key);
    }

    private void refreshCache() {
        // 模擬從數據庫或其他數據源加載數據
        for (String key : cache.keySet()) {
            CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
                return fetchDataFromDataSource(key);
            }, executorService);

            future.thenApply(data -> {
                cache.put(key, data);
                return data;
            });
        }
    }

    private String fetchDataFromDataSource(String key) {
        // 模擬從數據庫或其他數據源加載數據
        try {
            Thread.sleep(1000); // 模擬耗時操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Data for key: " + key;
    }

    public static void main(String[] args) {
        AsyncCacheLoader cacheLoader = new AsyncCacheLoader();
        System.out.println(cacheLoader.get("key1"));
    }
}

通過這些方法，可以實現異步加載緩存數據并確保線程非阻塞，從而提高系統的性能和響應速度。