2.3.1 Java内存缓存

目录

2.3.1.1 缓存介绍

1、什么是缓存

2、为什么要用缓存

2.3.1.2 自研Java内存缓存

1、场景

2、方案

2.3.1.3 谷歌guava提供的缓存

---

2.3.1.1 缓存介绍

1、什么是缓存

        在计算中，缓存是一个高速数据存储层，其中存储了数据子集，且通常是短暂性存储，这样日后再次请求此
    数据时，速度要比访问数据的主存储位置快。通过缓存，你可以高效地重用之前检索或计算的数据。

2、为什么要用缓存

2.3.1.2 自研Java内存缓存

1、场景

        在java应用中，对于访问频率高，更新少的数据，通常的方案是将这类数据加入缓存中。
    相对从数据库中读取来说，读缓存效率会有很大提升。
        在集群环境中，常用的分布式缓存有Redis、Memcached等。但在某些业务场景上，可能不需要去搭建一套
    复杂的分布式缓存系统，在单机环境下，通常是会希望使用内部的缓存(LocalCache)。

2、方案

    1、基于JSR107规范自研
    2、基于ConcurrentHashMap实现数据缓存
        了解一下就行，因为~没太多的应用：http://jcp.org/en/jsr/detail?id=107

package com.study.cache.java;

import java.lang.ref.SoftReference;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

// 用map实现一个简单的缓存功能
public class MapCacheDemo {

    // 我使用了  ConcurrentHashMap，线程安全的要求。
    //我使用SoftReference <Object>  作为映射值，因为软引用可以保证在抛出OutOfMemory之前，如果缺少内存，将删除引用的对象。
    //在构造函数中，我创建了一个守护程序线程，每5秒扫描一次并清理过期的对象。
    private static final int CLEAN_UP_PERIOD_IN_SEC = 5;

    private final ConcurrentHashMap<String, SoftReference<CacheObject>> cache = new ConcurrentHashMap<>();

    public MapCacheDemo() {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Thread.sleep(CLEAN_UP_PERIOD_IN_SEC * 1000);
                    cache.entrySet().removeIf(entry -> Optional.ofNullable(entry.getValue()).map(SoftReference::get).map(CacheObject::isExpired).orElse(false));
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        Thread cleanerThread = thread;
        cleanerThread.setDaemon(true);
        cleanerThread.start();
    }

    public void add(String key, Object value, long periodInMillis) {
        if (key == null) {
            return;
        }
        if (value == null) {
            cache.remove(key);
        } else {
            long expiryTime = System.currentTimeMillis() + periodInMillis;
            cache.put(key, new SoftReference<>(new CacheObject(value, expiryTime)));
        }
    }

    public void remove(String key) {
        cache.remove(key);
    }

    public Object get(String key) {
        return Optional.ofNullable(cache.get(key)).map(SoftReference::get).filter(cacheObject -> !cacheObject.isExpired()).map(CacheObject::getValue).orElse(null);
    }

    public void clear() {
        cache.clear();
    }

    public long size() {
        return cache.entrySet().stream().filter(entry -> Optional.ofNullable(entry.getValue()).map(SoftReference::get).map(cacheObject -> !cacheObject.isExpired()).orElse(false)).count();
    }

    // 缓存对象value
    private static class CacheObject {
        private Object value;
        private long expiryTime;

        private CacheObject(Object value, long expiryTime) {
            this.value = value;
            this.expiryTime = expiryTime;
        }

        boolean isExpired() {
            return System.currentTimeMillis() > expiryTime;
        }

        public Object getValue() {
            return value;
        }

        public void setValue(Object value) {
            this.value = value;
        }
    }
}

2.3.1.3 谷歌guava提供的缓存

1、Guava Cache介绍
    Guava Cache是google guava中的一个内存缓存模块，用于将数据缓存到JVM内存中。
    实际项目开发中经常将一些公共或者常用的数据缓存起来方便快速访问。
    使用场景：
        1、愿意消耗一些内存空间来提升速度
        2、预料到某些键会被查询一次以上
        3、缓存中存放的数据总量不会超出内存容量
    Guava Cache是单个应用运行时的本地缓存。它不把数据存放到文件或外部服务器。
    如果这不符合你的需求，可以尝试Memcached、Redis这类工具。

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>27.0.1-jre</version>
        </dependency>

E:\meWork\study\project\subject-2\subject-2-cache\java-demo\src\main\java\com\study\cache\java\guava\GuavaCacheDemo.java

package com.study.cache.java.guava;

import com.google.common.cache.*;
import com.study.cache.java.pojo.User;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

// https://github.com/google/guava
public class GuavaCacheDemo {
    public static void main(String[] args) throws ExecutionException {
        //缓存接口这里是LoadingCache，LoadingCache在缓存项不存在时可以自动加载缓存
        LoadingCache<String, User> userCache
                //CacheBuilder的构造函数是私有的，只能通过其静态方法newBuilder()来获得CacheBuilder的实例
                = CacheBuilder.newBuilder()
                //设置并发级别为8，并发级别是指可以同时写缓存的线程数
                .concurrencyLevel(8)
                //设置写缓存后8秒钟过期
                .expireAfterWrite(8, TimeUnit.SECONDS)
                //设置写缓存后1秒钟刷新
                .refreshAfterWrite(1, TimeUnit.SECONDS)
                //设置缓存容器的初始容量为10
                .initialCapacity(10)
                //设置缓存最大容量为100，超过100之后就会按照LRU最近虽少使用算法来移除缓存项
                .maximumSize(100)
                //设置要统计缓存的命中率
                .recordStats()
                //设置缓存的移除通知
                .removalListener(new RemovalListener<Object, Object>() {
                    @Override
                    public void onRemoval(RemovalNotification<Object, Object> notification) {
                        System.out.println(notification.getKey() + " 被移除了，原因： " + notification.getCause());
                    }
                })
                //build方法中可以指定CacheLoader，在缓存不存在时通过CacheLoader的实现自动加载缓存
                .build(
                        new CacheLoader<String, User>() {
                            @Override
                            public User load(String key) throws Exception {
                                System.out.println("缓存没有时，从数据库加载" + key);
                                // TODO jdbc的代码~~忽略掉
                                return new User("tony" + key, key);
                            }
                        }
                );

        // 第一次读取
        for (int i = 0; i < 20; i++) {
            User user = userCache.get("uid" + i);
            System.out.println(user);
        }

        // 第二次读取
        for (int i = 0; i < 20; i++) {
            User user = userCache.get("uid" + i);
            System.out.println(user);
        }
        System.out.println("cache stats:");
        //最后打印缓存的命中率等 情况
        System.out.println(userCache.stats().toString());
    }
}