3. java缓存-线程内缓存guava cache

3. java缓存-线程内缓存guava cacheguavacache的缓存结构常用的guavacache缓存根据上图中的缓存框架,我们常用的一些缓存实例有:LocalManualCache和LocalLoadingCache,两者唯一的区别就是LocalLoadingCacheextendsLocalManualCacheimplementsLoadingCache<K,V>接口。LocalManualCache…

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

guava cache的缓存结构

在这里插入图片描述

常用的guava cache缓存

根据上图中的缓存框架,我们常用的一些缓存实例有:LocalManualCache和LocalLoadingCache,两者唯一的区别就是LocalLoadingCache extends LocalManualCache implements LoadingCache<K,V>接口。
LocalManualCache和LocalLoadingCache两者都是对LoaclCache的包装,而LocalCache就是一个缓存的存储器,通过继承AbstractMap和实现ConcurrentMap接口,实现了支持并发的本地map(可以看成类似的ConcunrrentHashMap),LocalCache不对外暴露,因此只能通过其他方式提供实例,这就是CacheBuilder,以后建议大家也可以通过Builder的形式对外暴露实例。

范例

手动加载缓存

手动加载缓存:需要提前把数据put,当数据不存在返回null

public class MyCache {
    private static Cache<String,Object> cache;
    static {
	    // removeListener 从缓存中移除,调用这个方法
	    // initialCapacity 初始化容量
	    // concurrentLevel 并发的线程数
	    // expireAfterWrite 写入多长时间后,失效
        cache = CacheBuilder.newBuilder()
                .removalListener(new RemovalListener<Object, Object>() {
                    @Override
                    public void onRemoval(RemovalNotification<Object, Object> removalNotification) {
                        System.out.println("remove  "+removalNotification.getKey()+":"+removalNotification.getValue());
                    }
                })
                .initialCapacity(30)
                .concurrencyLevel(5)
                .expireAfterWrite(20, TimeUnit.MINUTES)
                .build();
        //手动加载数据
        cache.put("1","name11");
        cache.put("2","name12");
        cache.put("3","name13");
        cache.put("4","name14");
        cache.put("5","name15");
        cache.put("6","name16");
    }
    public static void main(String[] args) throws ExecutionException {
        //获取一个不存在的key
        System.out.println("------------------");
        System.out.println(cache.getIfPresent("7'"));
        //获取一个存在的key
        System.out.println(cache.getIfPresent("1"));
        //获取一个不存在的key,自己定义一个加载方法
        System.out.println(cache.get("7",new Callable(){
            @Override
            public Object call() throws Exception {
	            //返回值,一定不能为null
                return "dadad";
            }
        }));
        System.out.println(cache.getIfPresent("7"));
        cache.invalidate("1");
        System.out.println("------------------");
    }
}

----输出:
------------------
null
name11
dadad
dadad
remove  1:name11
------------------

上述缓存就可以看做是一个手动加载数据的缓存,即使用前自己手动的加载完成数据,当然也可以调用特殊的方法,当调用时,数据不存在后再调用加载方法。

自动加载缓存

自动加载缓存:不需要提前加载数据,当get时,不存在数据,会自动根据CacheLoader加载数据。

public class MyLoadingCache {
    
    public static void main(String[] args) {
        // 自动加载的缓存
        // expireAfterWrite 缓存加载指定时间后,自动失效
        // maximumSize 缓存数量超出指定数量后,加载新的缓存,会根据指定策略淘汰老的缓存
        // initialCapacity 创建是默认的大小
        // concurrencyLevel 并发线程数,类似于concurrentHashMap的segmentShift
        // CacheLoader 当缓存没有命中时,自动调用方法加载,返回值不能为空
        LoadingCache<String,User> loadingCache = CacheBuilder.newBuilder()
                .expireAfterWrite(30,TimeUnit.MINUTES)
                .maximumSize(300L)
                .concurrencyLevel(20)
                .initialCapacity(300)
                .build(new CacheLoader<String, User>() {
                    @Override
                    public User load(String key) throws Exception {
                        User user = getUserInfoFromDB(key);
                        return user;
                    }
                });
        System.out.println(loadingCache.getUnchecked("12").toString());

    }

    // 模拟从数据库获取数据
    private static User getUserInfoFromDB(String key) {
        if("123".equals(key)){
            //模拟数据库中不存在的数据
            return null;
        }
        return new User(key);
    }
}

class User{
    String id;

    public User(String id) {
        this.id = id;
    }
    @Override
    public String toString(){
        return "id="+this.id;
    }

} 

---输出内容
id=12

Cache和LoadingCache的醉醉哒区别,就是LoadingCache创建时,指定缓存未命中后的加载来源即可,同时还提供getUnchecked方法,如果你的CacherLoader没有返回检查异常,可以调用getUnchecked方法。

当我们在上述LoadingCache中执行:

System.out.println(loadingCache.getUnchecked("12").toString());
---输出:
Exception in thread "main" com.google.common.cache.CacheLoader$InvalidCacheLoadException: CacheLoader returned null for key 123.
	at com.google.common.cache.LocalCache$Segment.getAndRecordStats(LocalCache.java:2353)
	at com.google.common.cache.LocalCache$Segment.loadSync(LocalCache.java:2323)
	at com.google.common.cache.LocalCache$Segment.lockedGetOrLoad(LocalCache.java:2285)
	at com.google.common.cache.LocalCache$Segment.get(LocalCache.java:2200)
	at com.google.common.cache.LocalCache.get(LocalCache.java:3947)
	at com.google.common.cache.LocalCache.getOrLoad(LocalCache.java:3951)
	at com.google.common.cache.LocalCache$LocalLoadingCache.get(LocalCache.java:4874)
	at com.google.common.cache.LocalCache$LocalLoadingCache.getUnchecked(LocalCache.java:4880)

这就是LoadingCache的load方法,不能返回null。因此在load的时候,我们返回对象前必须处理null的问题。

Cache为什么不能返回null

先不说为什么不可以返回null,先假设cache可以接收null值。null的存在主要是影响判断加载的时机,下面列出两种情况下,判断加载的时机

允许null

get时,key不存在,返回的是null。
get时,key存在,缓存的value是null,返回的是null。
不能通过get的valuenull,来判断加载的时机,只能通过containsKey来判断,如果通过valuenull作为是否加载缓存的标准,就会产生一个问题,如果缓存的是null,那么即使加载过一次,但是每次get时,同样会再加载一次,这样就没有起到缓存的作用。

不允许null
get时,key不存在返回null,返回null。
get时,key存在,缓存的value不为null,返回非null值。
可以通过get的value==null,来判断加载时机。
根据上述两种方式,我们现在看看LocalCache中,如何处理get得到的null。
通过定位,找到LocalCache.Segment的如下代码

V get(K key, int hash, CacheLoader<? super K, V> loader) throws ExecutionException {
      checkNotNull(key);
      checkNotNull(loader);
      try {
        if (count != 0) { // read-volatile
          // don't call getLiveEntry, which would ignore loading values
          ReferenceEntry<K, V> e = getEntry(key, hash);
          if (e != null) {
            long now = map.ticker.read();
            V value = getLiveValue(e, now);
            if (value != null) {
              recordRead(e, now);
              statsCounter.recordHits(1);
              return scheduleRefresh(e, key, hash, value, now, loader);
            }
            ValueReference<K, V> valueReference = e.getValueReference();
            if (valueReference.isLoading()) {
              return waitForLoadingValue(e, key, valueReference);
            }
          }
        }
		// 看到这段注释,我们就发现,LocalCache是通过value == null,就进行load
        // at this point e is either null or expired;
        return lockedGetOrLoad(key, hash, loader);
      } catch (ExecutionException ee) {
        Throwable cause = ee.getCause();
        if (cause instanceof Error) {
          throw new ExecutionError((Error) cause);
        } else if (cause instanceof RuntimeException) {
          throw new UncheckedExecutionException(cause);
        }
        throw ee;
      } finally {
        postReadCleanup();
      }
    }

通过分析LocalCache代码,LocalCache是根据get的value==null来判断加载时机,因此通过load加载时,不允许返回null值,因此需要特殊判断load的返回值,建议使用Optional进行包装。

示例代码:

import com.google.common.base.Optional;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

import java.util.concurrent.TimeUnit;

public class UserLocalCache {
    
    private final LoadingCache<Long,Optional<User>> loadingCache = CacheBuilder.newBuilder()
            .expireAfterWrite(60*24, TimeUnit.MINUTES)
            .maximumSize(500)
            .build(new CacheLoader<Long, Optional<User>>() {
                @Override
                public Optional<User> load(Long key) throws Exception {
                    // 模拟访问数据库
                    User userFromDb = getUserFromDb(key);
                    // 使用Optional进行包装,虽然Optional里面为null,但是对cache来说,该对象不为空
                    return Optional.fromNullable(userFromDb);
                }
            });
    private UserLocalCache(){}

    public User getUser(Long userId){
        if(userId != null) {
            Optional<User> userOpt = loadingCache.getUnchecked(2L);
            if (userOpt.isPresent()) {
                return userOpt.get();
            }
        }
        return null;
    }
    

    private static User getUserFromDb(Long id) {
        Long temp = 1L;
        if(temp.equals(id)){
            return null;
        }else{
            return new User(id,"name"+id);
        }
    }
}

class User{
    private Long id;
    private String name;
    public User(Long id, String name){
        this.id = id;
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}

更多的guava cache的分析,请等待。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/185985.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • Windows安装gitlab_Windows7

    Windows安装gitlab_Windows7文章目录一、下载指引二、安装说明三、配置信息一、下载指引在Windows上使用Git,可以从Git官网https://git-scm.com/直接下载安装程序,然后按默认选项安装即可。StandaloneInstaller:安装版,安装完之后会自动在鼠标右键时显示GitGUIHere和GitBashHere(推荐)Portable(“thumbdriveedition”):绿色版,解压就能运行,免安装,不过绿色版不会在鼠标右键时显示GitGUIHere和Gi

  • javascript 向数组中添加数组元素(输入元素,不太重要)「建议收藏」

    javascript 向数组中添加数组元素(输入元素,不太重要)「建议收藏」javascript中向数组中输入元素,基本上有三种方式。1、在定义数组对象的时候,直接输入元素,varlist=newArrey(1,2,3,’内容’)2、利用数组对象的元素下标向其中输入数组元素list=newArray(9)list[2]=2list[3]=3这样list的下标是2与3的内容就添加上值了。3、可以利用for语句向数组对象中输入数组元素可以批量向数组对象中输入数组元素,一般用于对数组对象赋初始值,例如,可以通过改变变

  • Byakuren:一个 C 实现的主题色提取库「建议收藏」

    Byakuren:一个 C 实现的主题色提取库

  • kali无法安装arpspoof_kali怎么装arpspoof

    kali无法安装arpspoof_kali怎么装arpspoof第一步换源进入cd/etc/apt更换两个源地址devhttp://archive.ubuntu.com/ubuntu/trustymainuniverserestrictedmultiversedev-srchttps://mirrors.aliyun.com/kalikali-rollingmainnon-freecontrib图片为添加位置输入a…

  • ideal 2021 激活码【在线注册码/序列号/破解码】

    ideal 2021 激活码【在线注册码/序列号/破解码】,https://javaforall.cn/100143.html。详细ieda激活码不妨到全栈程序员必看教程网一起来了解一下吧!

  • java lang nullpointer_java.lang.throwable

    java lang nullpointer_java.lang.throwableIntentintent=registerReceiver(null,newIntentFilter(Intent.ACTION_BATTERY_CHANGED));查询电量的时候可以通过上面这种方式返回一个intent,从这个intent中也确实能够拿到我们想要要的信息,但是平常我们注册普通的广播的时候都习惯传入一个receiver,如果有电量改变就会不停的执行receiver的onR…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号