Java loci cache (occasus summus perficientur)

Java loci cache (princeps perficientur occasum)

2024-07-12

In mundo Iava, technologia caching late ad applicationis observantiam ampliandam adhibita est et maxime in duo genera dividitur: caching locales et caching remotos. Caching remota, cum sua praestantia observantia et flexibilitate, saepe per solutiones populares impletur, quales sunt Redis et Memcached. Cache locale, cum notis levibus et accessu suo, technologiae repraesentatur sicut HashMap, Guava Cache, Julius et Ehcache.

Mysteria in remotis speculandi in futuro blog postis trademus, sed hodie focus in caching locali. Articulus hic primum te per technologiam localem capiet ut tibi per visum comprehensivum praebeat. Deinde in technologiam caching trademus, ut rex effectus cognoscitur, et rationes et modos exsecutionis post illam explorabimus. Demum, per seriem casuum practicorum, demonstrabimus quomodo efficaciter utatur his summus perficientur technologiae localis in cotidiano opere ad meliorem efficiendi tui progressionem efficaciam et applicationem.

1. Java loci cache

1,1 HashMap

Exsecutione Tabulae substratae, obiectis conditivorum directe in memoria reponere possumus, quae recta et efficax ratio est.

Commodum: Haec methodus simplex et directa est, extra bibliothecas externas freta, et aptissima applicationibus simplicibus cautionibus ac missionibus simplicibus.

Incommoda: Attamen haec methodus sine mechanismo automatico cache eliminatione caret. Si magis provectae insidiae caching perficiendae sunt, altioris evolutionis evolutionis sumptibus requiri potest.


public class LRUCache extends LinkedHashMap {
 
    /**
     * 可重入读写锁，保证并发读写安全性
     */
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock readLock = readWriteLock.readLock();
    private Lock writeLock = readWriteLock.writeLock();
 
    /**
     * 缓存大小限制
     */
    private int maxSize;
 
    public LRUCache(int maxSize) {
        super(maxSize + 1, 1.0f, true);
        this.maxSize = maxSize;
    }
 
    @Override
    public Object get(Object key) {
        readLock.lock();
        try {
            return super.get(key);
        } finally {
            readLock.unlock();
        }
    }
 
    @Override
    public Object put(Object key, Object value) {
        writeLock.lock();
        try {
            return super.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }
 
    @Override
    protected boolean removeEldestEntry(Map.Entry eldest) {
        return this.size() > maxSize;
    }
}

1.2 Guava Cache

Guava Cache est technologiae caching ab Google evoluta quae in LRU (minus nuper adhibita) substitutio algorithmus innititur. Sed, cum Julius ortus, Guava Cache paulatim e conspectu hominum defluxit. Julius Guava Cache non modo commoda possidet, sed etiam multis in rebus superat. Etsi specifica specimen codicem hic non praebetur, lectores, qui in Guava Cache sunt, suum officium pro magis informatione visitare possunt.

Commodum: Guava Cache sustinet fines maximos capacitatis occasus et duas strategias exspirationis praebet: ex insertione temporis et temporis accessus et etiam functiones statisticas fundamentales sustinet.

IncommodaCum emissione Veris Booz 2 et Ver 5, Guava Cache non amplius utrique commendatur.

1.3 Julius

Caffeine fons patens est technologiae caching, qui algorithmus W-TinyLFU utitur, quod est consilium cache eliminatio quae utilitates LRU et LFU coniungit (frequentia minus adhibita). Caffeini cella facienda prope solutionem theoreticam optimalem est et haberi potest ut versio upgraded Guavae Cache.


public class CaffeineCacheTest {
 
    public static void main(String[] args) throws Exception {
        //创建guava cache
        Cache<String, String> loadingCache = Caffeine.newBuilder()
                //cache的初始容量
                .initialCapacity(5)
                //cache最大缓存数
                .maximumSize(10)
                //设置写缓存后n秒钟过期
                .expireAfterWrite(17, TimeUnit.SECONDS)
                //设置读写缓存后n秒钟过期,实际很少用到,类似于expireAfterWrite
                //.expireAfterAccess(17, TimeUnit.SECONDS)
                .build();
        String key = "key";
        // 往缓存写数据
        loadingCache.put(key, "v");
 
        // 获取value的值，如果key不存在，获取value后再返回
        String value = loadingCache.get(key, CaffeineCacheTest::getValueFromDB);
 
        // 删除key
        loadingCache.invalidate(key);
    }
 
    private static String getValueFromDB(String key) {
        return "v";
    }
}

1.4 Ehcache

Ehcache pura Java est in compage in- cessus caching notissima propter ieiunium et effectum efficientem. Notissimum est et servit provisor cache provisor defalta Hibernate.

Commodum : Ehcache amplis evictionem cache algorithmorum praebet, inter LFU (minus frequentius usus est), LRU (minus nuper adhibitus) et FIFO (primo in, primo e). Diversas rationes repositionis cella fovet, ut in acervum cella, cella extemporalitatis et cella orbis, ad diversas necessitates repositionis accommodare. Praeterea Ehcache etiam varias solutiones botri adiuvat, efficaciter solvendo problema de notitia communicationis.

Incommoda: Etsi multis aspectibus Ehcache excellit, parum deficit a Caffeine in effectu.


 
public class EncacheTest {
 
    public static void main(String[] args) throws Exception {
        // 声明一个cacheBuilder
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .withCache("encacheInstance", CacheConfigurationBuilder
                        //声明一个容量为20的堆内缓存
                        .newCacheConfigurationBuilder(String.class,String.class, ResourcePoolsBuilder.heap(20)))
                .build(true);
        // 获取Cache实例
        Cache<String,String> myCache =  cacheManager.getCache("encacheInstance", String.class, String.class);
        // 写缓存
        myCache.put("key","v");
        // 读缓存
        String value = myCache.get("key");
        // 移除换粗
        cacheManager.removeCache("myCache");
        cacheManager.close();
    }
}

2. summus perficientur cache Julius

2.1 Cache genus

2.1.1 Cache

Cache<Key, Graph> cache = Caffeine.newBuilder()    .expireAfterWrite(10, TimeUnit.MINUTES)    .maximumSize(10_000)    .build();
// 查找一个缓存元素， 没有查找到的时候返回nullGraph graph = cache.getIfPresent(key);// 查找缓存，如果缓存不存在则生成缓存元素,  如果无法生成则返回nullgraph = cache.get(key, k -> createExpensiveGraph(key));// 添加或者更新一个缓存元素cache.put(key, graph);// 移除一个缓存元素cache.invalidate(key);

Cache interface facultatem praebet elementorum conditivorum inveniendi, renovandi et removendi utentibus pervestigationibus expressis. Cum elementum conditivo generari non potest vel exceptio proicitur in processu generationis et generatio elementi deficit, cache.get nullum reddere potest.

2.1.2 Cache Loading

LoadingCache<Key, Graph> cache = Caffeine.newBuilder()    .maximumSize(10_000)    .expireAfterWrite(10, TimeUnit.MINUTES)    .build(key -> createExpensiveGraph(key));
// 查找缓存，如果缓存不存在则生成缓存元素,  如果无法生成则返回nullGraph graph = cache.get(key);// 批量查找缓存，如果缓存不存在则生成缓存元素Map<Key, Graph> graphs = cache.getAll(keys);

A Loading Cache est cella exsequenda Cache cum facultatem CacheLoader ei adiectam.
Si cella non adest, elementum cache respondente per CacheLoader.load generabitur.

2.1.3 Async Cache

AsyncCache<Key, Graph> cache = Caffeine.newBuilder()    .expireAfterWrite(10, TimeUnit.MINUTES)    .maximumSize(10_000)    .buildAsync();
// 查找一个缓存元素， 没有查找到的时候返回nullCompletableFuture<Graph> graph = cache.getIfPresent(key);// 查找缓存元素，如果不存在，则异步生成graph = cache.get(key, k -> createExpensiveGraph(key));// 添加或者更新一个缓存元素cache.put(key, graph);// 移除一个缓存元素cache.synchronous().invalidate(key);

AsyncCache forma est asynchrona Cache, facultatem exsecutoris generandi elementa cache et reditus CompletableFuture. Defectus piscinae exsequendi filo est ForkJoinPool.commonPool(), sed potes etiam eligere piscinam sequelam tuam domicilii ac perficiendi modum Caffeine.executor.

2.1.4 Async Loading Cache

AsyncLoadingCache<Key, Graph> cache = Caffeine.newBuilder()    .maximumSize(10_000)    .expireAfterWrite(10, TimeUnit.MINUTES)    // 你可以选择: 去异步的封装一段同步操作来生成缓存元素    .buildAsync(key -> createExpensiveGraph(key));    // 你也可以选择: 构建一个异步缓存元素操作并返回一个future    .buildAsync((key, executor) -> createExpensiveGraphAsync(key, executor));
// 查找缓存元素，如果其不存在，将会异步进行生成CompletableFuture<Graph> graph = cache.get(key);// 批量查找缓存元素，如果其不存在，将会异步进行生成CompletableFuture<Map<Key, Graph>> graphs = cache.getAll(keys);

AsyncLoadingCache forma asynchrona est LoadingCache, quae munus asynchronae oneris praebet ad elementa cache generandi.

2.2 Evictionem belli

Facultatem fundatur

// 基于缓存内的元素个数进行驱逐LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()    .maximumSize(10_000)    .build(key -> createExpensiveGraph(key));
// 基于缓存内元素权重进行驱逐LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()    .maximumWeight(10_000)    .weigher((Key key, Graph graph) -> graph.vertices().size())    .build(key -> createExpensiveGraph(key));

tempus fundatur

// 基于固定的过期时间驱逐策略LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()    .expireAfterAccess(5, TimeUnit.MINUTES)    .build(key -> createExpensiveGraph(key));LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()    .expireAfterWrite(10, TimeUnit.MINUTES)    .build(key -> createExpensiveGraph(key));
// 基于不同的过期驱逐策略LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()    .expireAfter(new Expiry<Key, Graph>() {      public long expireAfterCreate(Key key, Graph graph, long currentTime) {        // Use wall clock time, rather than nanotime, if from an external resource        long seconds = graph.creationDate().plusHours(5)            .minus(System.currentTimeMillis(), MILLIS)            .toEpochSecond();        return TimeUnit.SECONDS.toNanos(seconds);      }      public long expireAfterUpdate(Key key, Graph graph,           long currentTime, long currentDuration) {        return currentDuration;      }      public long expireAfterRead(Key key, Graph graph,          long currentTime, long currentDuration) {        return currentDuration;      }    })    .build(key -> createExpensiveGraph(key));

secundum citationem

// 当key和缓存元素都不再存在其他强引用的时候驱逐LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()    .weakKeys()    .weakValues()    .build(key -> createExpensiveGraph(key));
// 当进行GC的时候进行驱逐LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()    .softValues()    .build(key -> createExpensiveGraph(key));

2.3 Renovare mechanism

LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()    .maximumSize(10_000)    .refreshAfterWrite(1, TimeUnit.MINUTES)    .build(key -> createExpensiveGraph(key));

Refectio militaris solum in LoadingCache evictionis adhiberi potest, si elementum cella in recreatione quaesitum est, vetus valor restitutus erit, et novus valor recreatus non reddetur donec reficiatur elementi perfectio.

2.4 Statistics

Cache<Key, Graph> graphs = Caffeine.newBuilder() .maximumSize(10_000) .recordStats() .build();

Data collectio in modum Caffeine.recordStats() usus verti potest. Cache.stats () methodus objectum CacheStats reddet, quod aliquot indices statisticos continebit, ut:

hitRate(): Query cache hit rate
evictionCount () caches Number eiectis
averageLoadPenalty(): Mediocris tempus accipit pro novis valoribus onerari

Cum sedulo moderatoris a SpringBoot provisum, facile potes Cache usum investigare.

Technology sharing