本地缓存和分布式缓存

缓存

在服务端编程当中，缓存主要是指将数据库的数据加载到内存中，之后对该数据的访问都在内存中完成，从而减少了对数据库的访问，解决了高并发场景中数据库容易成为性能瓶颈的问题；以及基于内存的访问速度高于磁盘的访问速度的原理（数据库读取数据一般需要从磁盘读取），提高了数据的访问速度和程序性能。

根据缓存是否与应用进程属于同一进程，可以将内存分为本地缓存和分布式缓存。本地缓存是在同一个进程内的内存空间中缓存数据，数据读写都是在同一个进程内完成；而分布式缓存是一个独立部署的进程并且一般都是与应用进程部署在不同的机器，故需要通过网络来完成分布式缓存数据读写操作的数据传输

本地缓存

优缺点

1.访问速度快，但无法进行大数据存储

本地缓存相对于分布式缓存的好处是，由于数据不需要跨网络传输，故性能更好，但是由于占用了应用进程的内存空间，如Java进程的JVM内存空间，故不能进行大数据量的数据存储。

2.集群的数据更新问题

与此同时，本地缓存只支持被该应用进程访问，一般无法被其他应用进程访问，故在应用进程的集群部署当中，如果对应的数据库数据，存在数据更新，则需要同步更新不同部署节点的本地缓存的数据来包保证数据一致性，复杂度较高并且容易出错，如基于Redis的发布订阅机制来同步更新各个部署节点。

3.数据随应用进程的重启而丢失

由于本地缓存的数据是存储在应用进程的内存空间的，所以当应用进程重启时，本地缓存的数据会丢失。所以对于需要持久化的数据，需要注意及时保存，否则可能会造成数据丢失

适用场景

所以本地缓存一般适合于缓存只读数据，如统计类数据。或者每个部署节点独立的数据，如长连接服务中，每个部署节点由于都是维护了不同的连接，每个连接的数据都是独立的，并且随着连接的断开而删除。如果数据在集群的不同部署节点需要共享和保持一致，则需要使用分布式缓存来统一存储，实现应用集群的所有应用进程都在该统一的分布式缓存中进行数据存取即可

实现

缓存一般是一种key-value的键值对数据结构，所以需要使用字典数据结构来实现，在Java编程中，常用的字典实现包括HashMap和ConcurretHashMap。

与此同时，本地缓存由于需要被不同的服务端线程并发读写，故需要保证线程安全。由于HashMap不是线程安全的，而ConcurrentHashMap是线程安全的，故一般会使用ConcurrentHashMap来作为Java编程中的本地缓存实现。除此之外，也有其他更加智能的本地缓存实现，如可以定时失效，访问重新加载等特性，典型实现包括Google的guava工具包的Cache实现，这些也是线程安全的

Guava Cache

Guava Cache是在内存中缓存数据，相比较于数据库或redis存储，访问内存中的数据会更加高效。Guava官网介绍，下面的这几种情况可以考虑使用Guava Cache：

愿意消耗一些内存空间来提升速度。
预料到某些键会被多次查询。
缓存中存放的数据总量不会超出内存容量

所以，可以将程序频繁用到的少量数据存储到Guava Cache中，以改善程序性能。

构建缓存对象

接口Cache代表一块缓存，它有如下方法

public interface Cache<K, V> {	
    V get(K key, Callable<? extends V> valueLoader) throws ExecutionException;	
	
    ImmutableMap<K, V> getAllPresent(Iterable<?> keys);	
	
    void put(K key, V value);	
	
    void putAll(Map<? extends K, ? extends V> m);	
	
    void invalidate(Object key);	
	
    void invalidateAll(Iterable<?> keys);	
	
    void invalidateAll();	
	
    long size();	
	
    CacheStats stats();	
	
    ConcurrentMap<K, V> asMap();	
	
    void cleanUp();	
}

可以通过CacheBuilder类构建一个缓存对象，CacheBuilder类采用builder设计模式，它的每个方法都返回CacheBuilder本身，直到build方法被调用。构建一个缓存对象代码如下

public class StudyGuavaCache {	
    public static void main(String[] args) {	
        Cache<String,String> cache = CacheBuilder.newBuilder().build();	
        cache.put("word","Hello Guava Cache");	
        System.out.println(cache.getIfPresent("word"));	
    }	
}

上面的代码通过*CacheBuilder.newBuilder().build()*这句代码创建了一个Cache缓存对象，并在缓存对象中存储了key*为word，value*为Hello Guava Cache的一条记录。可以看到Cache非常类似于JDK中的Map，但是相比于Map，Guava Cache提供了很多更强大的功能

设置最大存储

Guava Cache可以在构建缓存对象时指定缓存所能够存储的最大记录数量。当Cache中的记录数量达到最大值后再调用put方法向其中添加对象，Guava会先从当前缓存的对象记录中选择一条删除掉，腾出空间后再将新的对象存储到Cache中

public class StudyGuavaCache {	
    public static void main(String[] args) {	
        Cache<String,String> cache = CacheBuilder.newBuilder()	
                .maximumSize(2)	
                .build();	
        cache.put("key1","value1");	
        cache.put("key2","value2");	
        cache.put("key3","value3");	
        System.out.println("第一个值：" + cache.getIfPresent("key1"));	
        System.out.println("第二个值：" + cache.getIfPresent("key2"));	
        System.out.println("第三个值：" + cache.getIfPresent("key3"));	
    }	
}

上面代码在构造缓存对象时，通过CacheBuilder类的maximumSize方法指定Cache最多可以存储两个对象，然后调用Cache的put方法向其中添加了三个对象。程序执行结果如下图所示，可以看到第三条对象记录的插入，导致了第一条对象记录被删除

1
2
3

第一个值：null
第二个值：value2
第三个值：value3

设置过期时间

在构建Cache对象时，可以通过CacheBuilder类的expireAfterAccess和expireAfterWrite两个方法为缓存中的对象指定过期时间，过期的对象将会被缓存自动删除。其中，expireAfterWrite方法指定对象被写入到缓存后多久过期，expireAfterAccess指定对象多久没有被访问后过期

public class StudyGuavaCache {	
    public static void main(String[] args) throws InterruptedException {	
        Cache<String,String> cache = CacheBuilder.newBuilder()	
                .maximumSize(2)	
                .expireAfterWrite(3,TimeUnit.SECONDS)	
                .build();	
        cache.put("key1","value1");	
        int time = 1;	
        while(true) {	
            System.out.println("第" + time++ + "次取到key1的值为：" + cache.getIfPresent("key1"));	
            Thread.sleep(1000);	
        }	
    }	
}

上面的代码在构造Cache对象时，通过CacheBuilder的expireAfterWrite方法指定put到Cache中的对象在3秒后会过期。在Cache对象中存储一条对象记录后，每隔1秒读取一次这条记录。程序运行结果如下图所示，可以看到，前三秒可以从Cache中获取到对象，超过三秒后，对象从Cache中被自动删除。

第1次取到key1的值为：value1
第2次取到key1的值为：value1
第3次取到key1的值为：value1
第4次取到key1的值为：null
第5次取到key1的值为：null
第6次取到key1的值为：null
第7次取到key1的值为：null
第8次取到key1的值为：null
第9次取到key1的值为：null

public class StudyGuavaCache {	
    public static void main(String[] args) throws InterruptedException {	
        Cache<String,String> cache = CacheBuilder.newBuilder()	
                .maximumSize(2)	
                .expireAfterAccess(3,TimeUnit.SECONDS)	
                .build();	
        cache.put("key1","value1");	
        int time = 1;	
        while(true) {	
            Thread.sleep(time*1000);	
            System.out.println("睡眠" + time++ + "秒后取到key1的值为：" + cache.getIfPresent("key1"));	
        }	
    }	
}

通过CacheBuilder的expireAfterAccess方法指定Cache中存储的对象如果超过3秒没有被访问就会过期。while中的代码每sleep一段时间就会访问一次Cache中存储的对象key1，每次访问key1之后下次sleep的时间会加长一秒。程序运行结果如下图所示，从结果中可以看出，当超过3秒没有读取key1对象之后，该对象会自动被Cache删除。

睡眠1秒后取到key1的值为：value1
睡眠2秒后取到key1的值为：value1
睡眠3秒后取到key1的值为：null
睡眠4秒后取到key1的值为：null
睡眠5秒后取到key1的值为：null
睡眠6秒后取到key1的值为：null
睡眠7秒后取到key1的值为：null

也可以同时用expireAfterAccess和expireAfterWrite方法指定过期时间，这时只要对象满足两者中的一个条件就会被自动过期删除

弱引用

可以通过weakKeys和weakValues方法指定Cache只保存对缓存记录key和value的弱引用。这样当没有其他强引用指向key和value时，key和value对象就会被垃圾回收器回收

public class StudyGuavaCache {	
    public static void main(String[] args) throws InterruptedException {	
        Cache<String,Object> cache = CacheBuilder.newBuilder()	
                .maximumSize(2)	
                .weakValues()	
                .build();	
        Object value = new Object();	
        cache.put("key1",value);	
	
        value = new Object();//原对象不再有强引用	
        System.gc();	
        System.out.println(cache.getIfPresent("key1"));	
    }	
}

上面代码的打印结果是null。构建Cache时通过weakValues方法指定Cache只保存记录值的一个弱引用。当给value引用赋值一个新的对象之后，就不再有任何一个强引用指向原对象。System.gc()触发垃圾回收后，原对象就被清除了。

显示清除

可以调用Cache的invalidateAll或invalidate方法显示删除Cache中的记录。invalidate方法一次只能删除Cache中一个记录，接收的参数是要删除记录的key。invalidateAll方法可以批量删除Cache中的记录，当没有传任何参数时，invalidateAll方法将清除Cache中的全部记录。invalidateAll也可以接收一个Iterable类型的参数，参数中包含要删除记录的所有key值。下面代码对此做了示例。

public class StudyGuavaCache {	
    public static void main(String[] args) throws InterruptedException {	
        Cache<String,String> cache = CacheBuilder.newBuilder().build();	
        Object value = new Object();	
        cache.put("key1","value1");	
        cache.put("key2","value2");	
        cache.put("key3","value3");	
	
        List<String> list = new ArrayList<String>();	
        list.add("key1");	
        list.add("key2");	
	
        cache.invalidateAll(list);//批量清除list中全部key对应的记录	
        System.out.println(cache.getIfPresent("key1"));	
        System.out.println(cache.getIfPresent("key2"));	
        System.out.println(cache.getIfPresent("key3"));	
    }	
}

代码中构造了一个集合list用于保存要删除记录的key值，然后调用invalidateAll方法批量删除key1和key2对应的记录，只剩下key3对应的记录没有被删除。

分布式缓存

参考redis

参考文献

本地缓存的优缺点/适用场景/实现

Guava Cache用法介绍

本地缓存和分布式缓存