技術共有

Java ローカル キャッシュ (高パフォーマンス設定)

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Java の世界では、キャッシュ テクノロジはアプリケーションのパフォーマンスを向上させるために広く使用されており、主にリモート キャッシュとローカル キャッシュの 2 つのカテゴリに分類されます。優れたパフォーマンスと柔軟性を備えたリモート キャッシュは、多くの場合、Redis や Memcached などの一般的なソリューションを通じて実装されます。軽量で高速なアクセス特性を備えたローカル キャッシュは、HashMap、Guava Cache、Caffeine、Ehcache などのテクノロジによって代表されます。

今後のブログ投稿でリモート キャッシュの謎を詳しく掘り下げていきますが、今日はローカル キャッシュに焦点を当てましょう。この記事では、まずローカル キャッシュ テクノロジについて説明し、包括的な概要を説明します。次に、パフォーマンスの王様として知られるキャッシュ テクノロジを詳しく掘り下げ、その背後にある原理と実装方法を探っていきます。最後に、一連の実践的なケースを通じて、これらの高性能ローカル キャッシュ テクノロジを日常業務で効果的に活用して、開発効率とアプリケーションのパフォーマンスを向上させる方法を示します。

1. Java ローカル キャッシュ

1.1 ハッシュマップ

Map の基礎となる実装を使用すると、キャッシュされるオブジェクトをメモリに直接保存できます。これは直接的かつ効率的な方法です。

アドバンテージ: この方法は、外部ライブラリに依存せずにシンプルかつ直接的であり、単純なキャッシュ要件と単純なシナリオを持つアプリケーションに非常に適しています。

短所: ただし、この方法には自動キャッシュ削除メカニズムがありません。より高度なキャッシュ戦略を実装する必要がある場合は、より高いカスタマイズ開発コストが必要になる可能性があります。

  1. public class LRUCache extends LinkedHashMap {
  2.  
  3.     /**
  4.      * 可重入读写锁，保证并发读写安全性
  5.      */
  6.     private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  7.     private Lock readLock = readWriteLock.readLock();
  8.     private Lock writeLock = readWriteLock.writeLock();
  9.  
  10.     /**
  11.      * 缓存大小限制
  12.      */
  13.     private int maxSize;
  14.  
  15.     public LRUCache(int maxSize) {
  16.         super(maxSize + 1, 1.0f, true);
  17.         this.maxSize = maxSize;
  18.     }
  19.  
  20.     @Override
  21.     public Object get(Object key) {
  22.         readLock.lock();
  23.         try {
  24.             return super.get(key);
  25.         } finally {
  26.             readLock.unlock();
  27.         }
  28.     }
  29.  
  30.     @Override
  31.     public Object put(Object key, Object value) {
  32.         writeLock.lock();
  33.         try {
  34.             return super.put(key, value);
  35.         } finally {
  36.             writeLock.unlock();
  37.         }
  38.     }
  39.  
  40.     @Override
  41.     protected boolean removeEldestEntry(Map.Entry eldest) {
  42.         return this.size() > maxSize;
  43.     }
  44. }

1.2 グアバキャッシュ

Guava Cache は、LRU (最も最近使用されていない) 置換アルゴリズムに基づいて Google によって開発されたキャッシュ テクノロジです。しかし、カフェインの台頭により、グアバ キャッシュは徐々に人々の目から消えていきました。 カフェインはグアバ キャッシュの利点を継承しているだけでなく、多くの点でそれを上回っています。ここでは具体的なサンプル コードは提供されていませんが、Guava Cache に興味のある読者は公式 Web サイトにアクセスして詳細を確認してください。

アドバンテージ: Guava Cache は、最大容量制限の設定をサポートし、挿入時間とアクセス時間に基づく 2 つの有効期限戦略を提供し、いくつかの基本的な統計関数もサポートします。

短所: Spring Boot 2 と Spring 5 のリリースにより、Guava Cache は両方で推奨されなくなりました。

1.3 カフェイン

Caffeine は、LRU と LFU (最小使用頻度) の利点を組み合わせたキャッシュ削除戦略である W-TinyLFU アルゴリズムを使用するオープン ソース キャッシュ テクノロジです。 Caffeine のキャッシュ パフォーマンスは理論上の最適解に近く、Guava Cache のアップグレード バージョンとみなすことができます。

  1. public class CaffeineCacheTest {
  2.  
  3.     public static void main(String[] args) throws Exception {
  4.         //创建guava cache
  5.         Cache<String, String> loadingCache = Caffeine.newBuilder()
  6.                 //cache的初始容量
  7.                 .initialCapacity(5)
  8.                 //cache最大缓存数
  9.                 .maximumSize(10)
  10.                 //设置写缓存后n秒钟过期
  11.                 .expireAfterWrite(17, TimeUnit.SECONDS)
  12.                 //设置读写缓存后n秒钟过期,实际很少用到,类似于expireAfterWrite
  13.                 //.expireAfterAccess(17, TimeUnit.SECONDS)
  14.                 .build();
  15.         String key = "key";
  16.         // 往缓存写数据
  17.         loadingCache.put(key, "v");
  18.  
  19.         // 获取value的值，如果key不存在，获取value后再返回
  20.         String value = loadingCache.get(key, CaffeineCacheTest::getValueFromDB);
  21.  
  22.         // 删除key
  23.         loadingCache.invalidate(key);
  24.     }
  25.  
  26.     private static String getValueFromDB(String key) {
  27.         return "v";
  28.     }
  29. }

1.4 キャッシュ

Ehcache は、高速で効率的なパフォーマンスで知られる Pure Java のインプロセス キャッシュ フレームワークです。これは広く認識されており、Hibernate のデフォルトのキャッシュ プロバイダーとして機能します。

アドバンテージ : Ehcache は、LFU (最も頻繁に使用されていない)、LRU (最も最近使用されていない)、FIFO (先入れ先出し) など、幅広いキャッシュ削除アルゴリズムを提供します。さまざまなストレージのニーズに適応するために、ヒープ内キャッシュ、オフヒープ キャッシュ、ディスク キャッシュなど、さまざまなタイプのキャッシュ ストレージをサポートしています。さらに、Ehcache はさまざまなクラスター ソリューションもサポートしており、データ共有の問題を効果的に解決します。

短所: Ehcache は多くの点で優れていますが、パフォーマンスの点では Caffeine にわずかに劣ります。

  1.  
  2. public class EncacheTest {
  3.  
  4.     public static void main(String[] args) throws Exception {
  5.         // 声明一个cacheBuilder
  6.         CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
  7.                 .withCache("encacheInstance", CacheConfigurationBuilder
  8.                         //声明一个容量为20的堆内缓存
  9.                         .newCacheConfigurationBuilder(String.class,String.class, ResourcePoolsBuilder.heap(20)))
  10.                 .build(true);
  11.         // 获取Cache实例
  12.         Cache<String,String> myCache =  cacheManager.getCache("encacheInstance", String.class, String.class);
  13.         // 写缓存
  14.         myCache.put("key","v");
  15.         // 读缓存
  16.         String value = myCache.get("key");
  17.         // 移除换粗
  18.         cacheManager.removeCache("myCache");
  19.         cacheManager.close();
  20.     }
  21. }

 

2. 高性能キャッシュカフェイン

2.1 キャッシュの種類

2.1.1 キャッシュ

 

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.get は null を返すことがあります。

2.1.2 キャッシュの読み込み

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);

 

LoadingCache は、CacheLoader 機能が追加された Cache のキャッシュ実装です。
キャッシュが存在しない場合は、対応するキャッシュ要素が CacheLoader.load を通じて生成されます。

2.1.3 非同期キャッシュ

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 はキャッシュの非同期形式であり、Executor がキャッシュ要素を生成して CompletableFuture を返す機能を提供します。デフォルトのスレッド プール実装は ForkJoinPool.commonPool() ですが、Caffeine.executor(Executor) メソッドをオーバーライドして実装することで、スレッド プールの選択をカスタマイズすることもできます。

2.1.4 非同期読み込みキャッシュ

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 は LoadingCache の非同期形式であり、キャッシュ要素を生成するための非同期ロードの機能を提供します。

2.2 立ち退き戦略

  • 容量ベース

// 基于缓存内的元素个数进行驱逐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));

  • 時間ベースの

// 基于固定的过期时间驱逐策略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));

  • 引用に基づく

// 当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 リフレッシュの仕組み

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

リフレッシュ戦略は、LoadingCache でのみ使用できます。エビクションとは異なり、リフレッシュ中にキャッシュ要素がクエリされた場合でも、その古い値は返されますが、要素のリフレッシュが完了するまで、リフレッシュされた新しい値は返されません。

2.4 統計

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

データ収集は、Caffeine.recordStats() メソッドを使用してオンにできます。 Cache.stats() メソッドは、次のようないくつかの統計指標を含む CacheStats オブジェクトを返します。

  • hitRate(): クエリキャッシュのヒット率

  • evictionCount(): 削除されるキャッシュの数

  • AverageLoadPenalty(): 新しい値がロードされるまでにかかる平均時間

SpringBoot が提供する RESTful コントローラーを使用すると、キャッシュの使用状況を簡単にクエリできます。

 

 

個人プロフィール

彼は 30 年以上テクノロジーの研究に専念しており、java、linux、javascript、php、css などのさまざまな言語に堪能であり、オープンソース分野で多くの貢献を行っています。将来の参考のために技術開発におけるいくつかの問題を共有する開発者ドキュメント ステーション。

プライベートな連絡先の最初の情報

送料