google开源库-guava缓存

最新推荐文章于 2024-07-10 21:49:17 发布
置顶 最新推荐文章于 2024-07-10 21:49:17 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： java 文章标签： java 缓存 guava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39788083/article/details/89945854
版权

guava是什么？

Guava是一种基于开源的Java库，其中包含谷歌正在由他们很多项目使用的很多核心库。这个库是为了方便编码，并减少编码错误。这个库提供用于集合，缓存，支持原语，并发性，常见注解，字符串处理，I/O和验证的实用方法。

guava的优势？

  • 标准化 - Guava库是由谷歌托管。
  • 高效 - 可靠，快速和有效的扩展JAVA标准库
  • 优化 -Guava库经过高度的优化

本文章主要讲解guava的缓存策略

缓存需要考虑的几大因素：

  • 缓存更新规则(主动、获取时更新、回源)
  • 获取缓存-gol策略(同步、异步)
  • 缓存清理规则(主动、定时_局部、数量、容量)

缓存辅助功能

  • 命中率
  • 缓存移除回调通知

缓存GOL策略

同步
//@Param timeout：过期时间
CacheBuilder.newBuilder()
	//某时间段内，读/写未访问调用load方法重新加载数据
	.expireAfterAccess(long time,TimeUnit time)
	.build(new CacheLoader<String, Object>() {
       @Override
       public Object load(String key) throws Exception {
           String value = "";//这里根据key，实现具体的获得value逻辑
           return value;
       }
   });

同步策略A：当key值第一次被访问或time范围内没有读写操作，调用load方法获取value值
优化点：当某个过期key被并发访问，那么就会有很多线程穿透guava获取数据，此类场景很容易造成雪崩效应。guava的处理办法是只允许一个线程获取数据，其他线程进行阻塞，直接获取新的数据

CacheBuilder.newBuilder()
   .refreshAfterWrite(long data,TimeUnit time)
   //某时间段内，更新未访问调用reload方法进行reflush
   .expireAfterAccess(long time,TimeUnit time)
   .build(new CacheLoader<String, Object>() {
      @Override
      public Object load(String key) throws Exception {
          String value = "";//这里根据key，实现具体的获得value逻辑
          return value;
      };
  });

同步策略B：当某个未过期key被并发访问且上次reflush超过了指定时间，抢到锁的某个线程调用reload方法重新获取数据
优化点：解决了同步策略A其他线程阻塞的问题，但抢到锁资源的线程同样会阻塞

异步
CacheBuilder.newBuilder()
.refreshAfterWrite(long data,TimeUnit time)
//某时间段内，更新未访问调用reload方法进行reflush
.expireAfterAccess(long time,TimeUnit time)
.build(new CacheLoader<String, Object>() {
     @Override
     public Object load(String key) throws Exception {
         String value = “”;//这里根据key，实现具体的获得value逻辑
         return value;
     };
     @Override
      public ListenableFuture<Object> reload(final String key,  Object oldValue) throws Exception {
          return executorService.submit(new Callable<Object>() {
          @Override
          public Object call() throws Exception {
             {
                     //dosomething
                     return value;
             } });                                                                     
        }
 });

异步策略：当某个未过期key被并发访问且上次reflush超过了指定时间，抢到锁的某个线程异步调用reload方法重新获取数据
优化点：解决了同步策略B抢到锁资源的线程会阻塞的问题，但完全异步需要构建一个线程池executorService，线程池的具体参数需视场景而定
注：使用reflush策略会产生一个问题，当某个key很长一段时间未访问，重新获得key值至少会有一个或多个线程返回的是旧值，这是因为guava的key值过期更新策略大部分是在gol的时候触发，如果追求数据的一致性，可以调用CacheBuilder.newBuilder().build().invalidate(key)方法强制刷新。

缓存清理规则

·设定全局数量

CacheBuilder.maximumSize(int num);

常用算法有FIFO(先进先出)，LRU(最近访问优先)，guava采用的是LRU算法
注：时间复杂度为O(1)的LRU算法，一般采用双链表+hash散列实现

·设定全局容量
CacheBuilder.maximumWeight(1024 * 1024 * 1024);

  CacheBuilder.newBuilder()
	.maximumWeight(1024 * 1024 * 1024) // 设置最大容量为 1M
	.weigher(new Weigher<String, String>() { 
		@Override
		public int weigh(String key, String value) {
			return key.getBytes().length + value.getBytes().length;
		}
	}).build();

. guava的容量大小可由客户端自己实现

·键值的定期清理

CacheBuilder.newBuilder()
	.expireAfterAccess(long time,TimeUnit unit) ;

CacheBuilder.newBuilder()
	.expireAfterWrite(long time,TimeUnit unit) ;
		
	. 规定时间范围内没有更新/查询操作，清理键值使用expireAfterAccess
	. 规定时间范围内没有更新操作，清理键值使用expireAfterWrite

·主动清除

//清理单个key
CacheBuilder.newBuilder().build().invalidate(key);
//清理全部key
CacheBuilder.newBuilder().build().invalidateAll();

guava gol分析

在这里插入图片描述

guava entry<K, V>寻址

第一步：
hash后高位截取 & (捅size-1)，寻到具体的Segument对象

Segment<K, V> segmentFor(int hash) {
  // TODO(fry): Lazily create segments?
  return segments[(hash >>> segmentShift) & segmentMask];
}

第二步：
hash & (AtomicReferenceArray的size-1)，寻到具体的ReferenceEntry链表

ReferenceEntry<K, V> getFirst(int hash) {
  // read this volatile field only once
  AtomicReferenceArray<ReferenceEntry<K, V>> table = this.table;
  return table.get(hash & (table.length() - 1));
}

第三步：
遍历链表获取entry对象，同时尝试调用tryDrainReferenceQueues()清理弱引用的数据

ReferenceEntry<K, V> getEntry(Object key, int hash) {
  for (ReferenceEntry<K, V> e = getFirst(hash); e != null; e = e.getNext()) {
    if (e.getHash() != hash) {
      continue;}
    K entryKey = e.getKey();
    if (entryKey == null) {
      tryDrainReferenceQueues();
      continue; }
    if (map.keyEquivalence.equivalent(key, entryKey)) {
      return e;
    }
  } return null; }

图解
在这里插入图片描述

guava entry<K, V>过期数据清理

通过队列poll遍历recencyQueue，先将entry插入到accessQueue头部(LRU算法的体现)。

void expireEntries(long now) {
  drainRecencyQueue();

  ReferenceEntry<K, V> e;
  while ((e = writeQueue.peek()) != null && map.isExpired(e, now)) {
    if (!removeEntry(e, e.getHash(), RemovalCause.EXPIRED)) {
      throw new AssertionError();
    }
  }
  while ((e = accessQueue.peek()) != null && map.isExpired(e, now)) {
    if (!removeEntry(e, e.getHash(), RemovalCause.EXPIRED)) {
      throw new AssertionError();
    }
  }
}
//清理之前的动作
 void drainRecencyQueue() {
    ReferenceEntry<K, V> e;
    while ((e = recencyQueue.poll()) != null) {
      // An entry may be in the recency queue despite it being removed from
      // the map . This can occur when the entry was concurrently read while a
      // writer is removing it from the segment or after a clear has removed
      // all of the segment's entries.
      if (accessQueue.contains(e)) {
        accessQueue.add(e);
      }
    }
  }
entry<K, V>超过阈值的清理流程

假设插入数据时，超过了每个Segment捅设置的最大值，从accessQueue队列尾部循环清理，直到小于阈值。
注：maxSegmentWeight=maxWeight/segmentSize，所以在设置阈值的时候，尽量要比真实值大一些。

 void evictEntries() {
   if (!map.evictsBySize()) {
     return;
   }
   drainRecencyQueue();
   //超过了每个Segment捅的最大值
   while (totalWeight > maxSegmentWeight) {
     ReferenceEntry<K, V> e = getNextEvictable();
     if (!removeEntry(e, e.getHash(), RemovalCause.SIZE)) {
       throw new AssertionError();
     }
   }
 }
 //清理顺序
 ReferenceEntry<K, V> getNextEvictable() {
   for (ReferenceEntry<K, V> e : accessQueue) {
     int weight = e.getValueReference().getWeight();
     if (weight > 0) {
       return e;  }  }
   throw new AssertionError(); }
guava LRU算法
  Segment<K, V> createSegment(
      int initialCapacity, long maxSegmentWeight, StatsCounter statsCounter) {
    return new Segment<K, V>(this, initialCapacity, maxSegmentWeight, statsCounter);
  }

初始化LocalCache时，会根据maxWeight构建一个Segments数组，Segments类似CurrentHashMap中捅的概念。当未设置maxWeight时，捅的大小是4，但捅在初始化后大小是不会变化的，所以maxNum或maxWeight最好配置一下。
我们来看看Segments的几个参数：

 Segment(LocalCache<K, V> map, int initialCapacity, long maxSegmentWeight,
     StatsCounter statsCounter) {
   this.map = map;
   this.maxSegmentWeight = maxSegmentWeight;
   this.statsCounter = checkNotNull(statsCounter);
   initTable(newEntryArray(initialCapacity));

   keyReferenceQueue = map.usesKeyReferences()
        ? new ReferenceQueue<K>() : null;

   valueReferenceQueue = map.usesValueReferences()
        ? new ReferenceQueue<V>() : null;

   recencyQueue = map.usesAccessQueue()
       ? new ConcurrentLinkedQueue<ReferenceEntry<K, V>>()
       : LocalCache.<ReferenceEntry<K, V>>discardingQueue();

   writeQueue = map.usesWriteQueue()
       ? new WriteQueue<K, V>()
       : LocalCache.<ReferenceEntry<K, V>>discardingQueue();

   accessQueue = map.usesAccessQueue()
       ? new AccessQueue<K, V>()
       : LocalCache.<ReferenceEntry<K, V>>discardingQueue();

 void initTable(AtomicReferenceArray<ReferenceEntry<K, V>> newTable) {
   this.threshold = newTable.length() * 3 / 4; // 0.75
   if (!map.customWeigher() && this.threshold == maxSegmentWeight) {
     // prevent spurious expansion before eviction
     this.threshold++;
   }
   this.table = newTable;
 }

AtomicReferenceArray<ReferenceEntry<K, V>> newTable
此数组用来维护缓存的kv数据，ReferenceEntry<K, V>是一个单链表，AtomicReferenceArray大小由maxWeight和argument数量共同决定，当AtomicReferenceArray达到 newTable.length() * 3 / 4大小后，按2的倍数进行扩容。
accessQueue
此队列(含双链表功能)用来维护移除读写过期的数据，同时维护移除numMax或weightMax等超量的数据
writeQueue
此队列(含双链表功能)用来维护移除写过期的数据
recencyQueue
此队列就是个简单的单链表，查询时插入到recencyQueue中，包含了重复、null值数据，LRU的雏形
keyReferenceQueue，valueReferenceQueue
被动触发非强引用的数据k，v数据，并将AtomicReferenceArray中的队列元素移除

accessQueue讲解：
accessQueue继承自AbstractQueue,同时具备了双链表的功能。
accessQueue重写了队列add中的offer方法，主要逻辑是找到链表中的位置并剔除同时维护前后索引关系并将新元素加入到尾部

    static final class AccessQueue<K, V> extends AbstractQueue<ReferenceEntry<K, V>> {
    final ReferenceEntry<K, V> head = new AbstractReferenceEntry<K, V>()}；
    
    @Override
    public boolean offer(ReferenceEntry<K, V> entry) {
      // unlink
      connectAccessOrder(entry.getPreviousInAccessQueue(), entry.getNextInAccessQueue());

      // add to tail
      connectAccessOrder(head.getPreviousInAccessQueue(), entry);
      connectAccessOrder(entry, head);

      return true;
    }

recencyQueue讲解：
recencyQueue继承自ConcurrentLinkedQueue，属于线程安全的链表队列，recencyQueue只在guava调用查询、更新方法时触发add，entry的更新操作(删除、更新)并不会触发recencyQueue的poll方法，故recencyQueue包含了失效及重复的数据。
recencyQueue的主要目的通过队列记录每次访问的key，真正有数据需要expire、evict时触发调整accessQueue链表元素的位置。 accessQueue才是真正的LRU队列

@GuardedBy("this")
void drainRecencyQueue() {
  ReferenceEntry<K, V> e;
  while ((e = recencyQueue.poll()) != null) {
    // An entry may be in the recency queue despite it being removed from
    // the map . This can occur when the entry was concurrently read while a
    // writer is removing it from the segment or after a clear has removed
    // all of the segment's entries.
    if (accessQueue.contains(e)) {
      accessQueue.add(e);
    }
  }
}

注：update方法的LRU策略会在调用drainRecencyQueue后维护，这样就保证了LRU读写的顺序

void recordWrite(ReferenceEntry<K, V> entry, int weight, long now) {
  // we are already under lock, so drain the recency queue immediately
  drainRecencyQueue();
  totalWeight += weight;

  if (map.recordsAccess()) {
    entry.setAccessTime(now);
  }
  if (map.recordsWrite()) {
    entry.setWriteTime(now);
  }
  accessQueue.add(entry);
  writeQueue.add(entry);
}
guava reload分析

在这里插入图片描述
loadAsyn()分为两步，1、调用loadFuture() reload数据 2、reload完成后，调用addListener()回调，回调内容是将数据通过线程池异步刷新到值栈中， 性能的提升仅限于未重写reload方法的用户


ListenableFuture<V> loadAsync(final K key, final int hash,
       final LoadingValueReference<K, V> loadingValueReference, CacheLoader<? super K, V> loader) {
     final ListenableFuture<V> loadingFuture = loadingValueReference.loadFuture(key, loader);
     loadingFuture.addListener(
         new Runnable() {
           @Override
           public void run() {
             try {
               V newValue = getAndRecordStats(key, hash, loadingValueReference, loadingFuture);
             } catch (Throwable t) {
               logger.log(Level.WARNING, "Exception thrown during refresh", t);
               loadingValueReference.setException(t);
             }
           }
         }, directExecutor());
     return loadingFuture;
   }

在这里插入图片描述
注意：如未重写reload方法，将阻塞调用load方法加载数据

    @GwtIncompatible("Futures")
    public ListenableFuture<V> reload(K key, V oldValue) throws Exception {
        Preconditions.checkNotNull(key);
        Preconditions.checkNotNull(oldValue);
        return Futures.immediateFuture(this.load(key));
    }
子亮_czl
关注
专栏目录
spring-boot-redis-guava-caffeine-cache:springboot 使用 redis guava caffeine 缓存示例
05-17
Guava Cache是Google Guava库的一部分，提供了一个本地内存缓存解决方案。在Spring Boot中，我们可以创建一个`CacheManager`的实现，使用`GuavaCacheManager`并配置缓存大小、过期策略等。Guava Cache适用于对数据...
jackson-datatype-guava-2.8.0.zip
10-10
Jackson Datatype Guava是Jackson的一个扩展，它为Google的Guava库提供了支持。Guava是一个强大的Java工具集，包含了各种实用的集合类、缓存机制、并发工具、函数式编程接口等。通过Jackson Datatype Guava，我们...
Guava 3-缓存
weixin_34150224的博客
11-02 149
缓存，在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说，cache 就是为了提升系统性能而开辟的一块内存空间。 　　缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日常开发的很多场合，由于受限于硬盘IO的性能或者我们自身业务系统的数据处理和获取可能非常费时，当我们发现我们的系统这个数据请求量很大的时候，频繁的IO和频繁的逻辑处理会导致硬盘和CPU资源的...
ReferenceQueue的使用
weixin_33901926的博客
12-08 204
转：http://www.iflym.com/index.php/java-programe/201407140001.html 1 何为ReferenceQueue 在java的引用体系中，存在着强引用，软引用，虚引用，幽灵引用，这4种引用类型。在正常的使用过程中，我们定义的类型都是强引用的，这种引用类型在回收中，只有当其它对象没有对这个对象的引用时，才会被GC回收掉。简单来说，对于以下定义...
Google Guava Cache简介
最新发布
weixin_43739821的博客
07-10 874
Google Guava Cache简介 和Redis的区别
Guava LoadCache缓存介绍和使用
熊與貓v
08-12 2393
一般情况下，在缓存中查询某个key，如果不存在，则查源数据，并回填缓存。一般我们在业务中操作缓存，都会操作缓存和数据源两部分GuavaCache的get可以集成数据源，在从缓存中读取不到时可以从数据源中读取数据并回填缓存。GuavaCache可以在CacheLoader的load方法中加以控制，对同一个key，只让一个请求去读源并回填缓存，其他请求阻塞等待。GuavaCache构建的缓存不会"自动"执行清理和回收工作，也不会在某个缓存项过期后马上清理，也没有诸如此类的清理机制。...
guava 本地缓存使用
会飞的时钟
11-23 397
使用guava cache 创建一个本地缓存，结合redis缓存，形成二级缓存  // 定义一个本地缓存 ListeningExecutorService refreshPools = MoreExecutors .listeningDecorator(Executors.newFixedThreadPool(RELOAD_CACHE_THREADS)); LoadingCache&...
CacheBuilder.newBuilder() 使用cache机制
热门推荐
新一的技术笔记
02-19 2万+
cache用来比如对于同样一次输入不止一次的取值的时候，使用缓存。 公司使用cache进行缓存token，时效一天，但是经常过期，找不到原因，故来学习一下缓存机制。 使用的是guava本地缓存，并没有使用redis作为缓存机制 公司使用的是 package com.google.common.cache; 来进行的缓存 我的怀疑是 1.有可能是cache的池的大小负载过了 2.可能是...
Google的CacheBuilder缓存
luzhensmart的专栏
06-17 2万+
1:refreshAfterWrite Guava Cache特性：对于同一个key，只让一个请求回源load数据，其他线程阻塞等待结果这种情况：如果缓存过期，恰好有多个线程读取同一个key的值，那么guava只允许一个线程去加载数据，其余线程阻塞。这虽然可以防止大量请求穿透缓存，但是效率低下。使用refreshAfterWrite可以做到：只阻塞加载数据的线程，其余线程返回旧数据。 2:...
google-guava所需依赖包，listenablefuture-9999.0-empty-to-avoid-conflic
06-29
Google Guava是Google为Java平台设计的一个开源库，它包含了许多针对Java集合框架的增强，如更强大的Map和Set实现，以及对并发、缓存、I/O操作的高级支持。Guava还提供了事件bus、函数式编程工具、字符串处理、缓存...
java基础 集合-26-Guava开源组件使用(4)
09-25
Guava是由Google开发并维护的一个强大的Java工具库，它包含了许多实用的集合类、缓存机制、并发工具、字符串处理函数以及I/O工具等。Guava不仅提供了许多标准Java集合框架的扩展，还引入了一些创新性的数据结构和...
Guava-Cache-Demo:演示如何使用 Guava 缓存
07-04
Guava Cache 是 Google 开源库 Guava 提供的一种高效、易用的缓存解决方案，它旨在帮助开发者在 Java 应用程序中实现本地缓存策略，以提高性能和减少对远程服务的调用。在这个名为 "Guava-Cache-Demo" 的项目中，...
Guava Cache LoadingCache 之 refreshAfterWrites和expireAfterWrite区别 使用说明
fengbin2005的专栏
07-15 6582
三种基于时间清理或刷新缓存数据的方式： expireAfterAccess: 当缓存项在指定的时间段内没有被读或写就会被回收。 expireAfterWrite：当缓存项在指定的时间段内没有更新就会被回收（移除key），需要等待获取新值才会返回。 refreshAfterWrite：当缓存项上一次更新操作之后的多久会被刷新。第一个请求进来，执行load把数据加载到内存中（同步过程），指定的过期时间内比如10秒，都是从cache里读取数据。过了10秒后，没有请求进来，不会移除key。再有请求过来，才则执行
关于google-Guava的cache
m0_37808871的博客
04-22 236
背景：公司又到谷歌的cache。我在数据库直接修改数据并没用，需要重启项目才可以，或者是通过管理后台页面操作才有效，然后我就去查了相关资料 资料说这个com.goolgle.common.cache.Cache包里的方法是将一些量少但经常使用到的数据获取后放在本地内存中 然后我自己有三个不太确定的地方，网上还找不到想要的答案 1：本地内存是放在虚拟机里面吗，当虚拟机重启时第一次查询时就会获取数据...
Guava Cache 异步刷新技巧
weixin_54449574的博客
01-07 1102
Guava Cache 非常强大，但它并没有后台任务线程异步的执行 load 或者 reload 方法，而是通过请求线程来执行相关操作。减少过期的频率 ，也就是减少执行 load 方法的频率 ，配置 refresh < expire。采用异步刷新的策略，也就是线程异步加载数据，期间所有请求返回旧的缓存值。
Web开发缓存使用
火焰云的博客
04-29 426
java开发的两种缓存框架使用实例。
消息队列的两种模式及实现
noaman_wgs的博客
04-28 1万+
转载：http://blog.csdn.net/heyutao007/article/details/50131089 Java消息服务（Java Message Service，JMS）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。 点对点与发布订阅最初是由JMS定义的。这两种模式主要区别或解决的问
Guava 源码分析（Cache 原理【二阶段】）
weixin_33774883的博客
07-15 157
前言 在上文「Guava 源码分析（Cache 原理）」中分析了 Guava Cache 的相关原理。 文末提到了回收机制、移除时间通知等内容，许多朋友也挺感兴趣，这次就这两个内容再来分析分析。 在开始之前先补习下 Java 自带的两个特性，Guava 中都有具体的应用。 Java 中的引用 首先是 Java 中的引用。 在之前分享过 JVM 是根据可达性分析算法找出需要回收的对象，判断对象的...
Guava Cache特性：refreshAfterWrite只阻塞回源线程，其他线程返回旧值
weixin_34220834的博客
02-24 415
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值