Cache pemuatan malas dalam teknologi caching Java

Cache lazy loading dalam teknologi caching Java

Dalam bulatan Java, teknologi caching ialah teknologi yang sangat biasa. Tujuan caching adalah untuk meningkatkan prestasi capaian data dan mengelakkan pengiraan berulang dan permintaan berulang. Teknologi caching mempunyai pelbagai senario aplikasi, terutamanya dalam aplikasi yang memerlukan akses kerap kepada data, seperti tapak web e-dagang, portal berita, aplikasi sosial, dsb.

Walau bagaimanapun, teknologi caching juga mempunyai beberapa kelemahan, seperti: permulaan cache dan kemas kini mungkin memakan banyak masa dan sumber prestasi. Oleh itu, untuk meningkatkan prestasi dan kecekapan cache, teknologi yang dipanggil "pemuatan malas cache" telah muncul, yang boleh menyelesaikan masalah permulaan dan kemas kini cache dengan berkesan, dengan itu meningkatkan prestasi dan kecekapan sistem.

Apakah pemuatan malas dicache?

Pemuatan malas cache bermakna menangguhkan permulaan data cache dan menunggu akses pertama sebelum memuatkan data ke dalam cache. Kelebihan teknologi ini ialah ia boleh mengelakkan operasi permulaan dan kemas kini yang tidak perlu, dengan itu mengurangkan overhed sistem dan penggunaan sumber. Sudah tentu, kelemahan pemuatan malas cache ialah ia mungkin menyebabkan beberapa kelewatan semasa akses pertama, tetapi dalam kebanyakan senario aplikasi, kelewatan ini boleh diterima. Oleh itu, teknologi pemuatan malas cache adalah teknologi yang sangat biasa dalam banyak aplikasi.

Cara melaksanakan cache lazy loading

Di Java, terdapat banyak cara untuk melaksanakan cache lazy loading Di sini kami memperkenalkan beberapa kaedah pelaksanaan biasa.

Kaedah 1: Gunakan ConcurrentHashMap dan Future untuk melaksanakan

ConcurrentHashMap ialah jadual cincang selamat benang yang diperkenalkan dalam JDK 1.5, yang boleh digunakan untuk menyimpan data cache, manakala Future boleh digunakan untuk memuatkan data secara tak segerak.

Kaedah pelaksanaan khusus adalah seperti berikut:

public class MyCache {
    private final Map<String, Future<String>> cache = new ConcurrentHashMap<>();
    private final Function<String, String> loadDataFunction;

    public MyCache(Function<String, String> loadDataFunction) {
        this.loadDataFunction = loadDataFunction;
    }

    public String getData(String key) throws ExecutionException, InterruptedException {
        Future<String> future = cache.get(key);

        if (future == null) {
            Callable<String> callable = () -> loadDataFunction.apply(key);
            FutureTask<String> futureTask = new FutureTask<>(callable);
            future = cache.putIfAbsent(key, futureTask);  
            if (future == null) {
                future = futureTask;
                futureTask.run();
            }
        }
        return future.get();
    }
}

Kaedah pelaksanaan ini agak mudah, dan proses umum adalah seperti berikut:

1. Cuba dapatkan Masa Depan nilai kunci yang ditentukan daripada cache;
2. Jika nilai Masa Depan adalah batal, ini bermakna data yang sepadan belum dicache, muatkan data melalui loadDataFunction, masukkannya ke dalam objek FutureTask, dan masukkan ke dalam cache;
3. Jika sisipan berjaya (iaitu, sebelum Tiada utas lain telah memasukkan kunci), kemudian jalankan FutureTask untuk memuatkan data secara tak segerak; sepadan dengan kunci yang ditentukan dalam cache.
4. Kaedah 2: Gunakan Penguncian Disemak Dua Kali untuk mencapai

Penguncian Disemak Dua Kali ialah teknik pengaturcaraan berbilang benang biasa yang boleh mengelakkan persaingan kunci berulang dan dengan itu meningkatkan prestasi sistem. Dalam pemuatan malas cache, anda boleh menggunakan teknik Penguncian Disemak Dua Kali untuk mencapai kesan permulaan tertunda.

Kaedah pelaksanaan khusus adalah seperti berikut:

public class MyCache {
    private Map<String, String> cache = null;

    public String getData(String key) {
        String data = cache.get(key);
        if (data == null) {
            synchronized (this) {
                data = cache.get(key);

                if (data == null) {
                    data = loadData(key);
                    cache.put(key, data);
                }
            }
        }
        return data;
    }

    private String loadData(String key) {
        // TODO: load data from database or remote API
        return "data";
    }
}

Kaedah pelaksanaan ini agak mudah, dan proses umum adalah seperti berikut:

Cuba dapatkan nilai daripada kunci yang ditentukan daripada cache;

1. Jika nilainya adalah batal, laksanakan blok kod yang disegerakkan; null, panggil kaedah loadData untuk memuatkan data dan simpannya dalam Dalam cache
2. Akhir sekali, kembalikan data yang sepadan dengan kunci yang ditentukan.
3. Kaedah 3: Gunakan AtomicReference untuk mencapai
4. AtomicReference ialah kelas operasi atom yang diperkenalkan dalam JDK 1.5, yang boleh digunakan untuk mencapai kesan pemuatan malas cache.

Kaedah pelaksanaan khusus adalah seperti berikut:

public class MyCache {
    private final Map<String, String> cache = new ConcurrentHashMap<>();
    private final AtomicReference<Map<String, String>> reference =
            new AtomicReference<>(null);

    public String getData(String key) {
        Map<String, String> currentCache = reference.get();

        if (currentCache == null) {
            currentCache = cache;
            reference.compareAndSet(null, currentCache);
        }

        return currentCache.computeIfAbsent(key, k -> loadData(k));
    }

    private String loadData(String key) {
        // TODO: load data from database or remote API
        return "data";
    }
}

Kaedah pelaksanaan ini agak rumit, dan proses umum adalah seperti berikut:

Cuba baca cache data yang ditunjukkan oleh rujukan;

Jika data cache adalah batal, baca data daripada ConcurrentHashMap dan simpannya dalam AtomicReference sebagai data asal; data yang sepadan dengan kunci yang ditentukan daripada data yang dicache;

1. Jika data yang sepadan dengan kunci yang ditentukan tidak wujud, panggil kaedah loadData untuk memuatkan data, simpannya dalam data cache dan kembalikan data .
2. Apakah faedah menggunakan pemuatan malas yang dicache?
3. Menggunakan teknologi pemuatan malas cache boleh membawa faedah berikut:

Mengurangkan permulaan dan kemas kini overhed dan penggunaan sumber

Elakkan pengiraan dan permintaan yang tidak berguna;

Tingkatkan kelajuan tindak balas dan daya pemprosesan sistem;

1. Kurangkan jejak memori dan overhed sistem
2. Meningkatkan kebolehselenggaraan dan kebolehskalaan sistem.
3. Ringkasan
4. Dalam teknologi caching Java, pemuatan malas cache ialah teknologi yang sangat praktikal. Dengan melambatkan permulaan data cache, pengiraan yang tidak perlu dan operasi permintaan boleh dielakkan, meningkatkan prestasi dan kecekapan sistem. Artikel ini memperkenalkan beberapa kaedah pelaksanaan pemuatan malas cache biasa, dengan harapan dapat membantu semua orang memahami dan menguasai teknologi caching Java dengan lebih mendalam.

Atas ialah kandungan terperinci Cache pemuatan malas dalam teknologi caching Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!