版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
1.缓存粒度控制
通俗来讲，缓存粒度问题就是我们在使用缓存时，是将所有数据缓存还是缓存部分数据？
| 数据类型 | 通用性 | 空间占用（内存空间+网络码率） | 代码维护 |
|---|---|---|---|
| 全部数据 | 高 | 大 | 简单 |
| 部分数据 | 低 | 小 | 较为复杂 |
缓存粒度问题是一个容易被忽视的问题，如果使用不当，可能会造成很多无用空间的浪费，可能会造成网络带宽的浪费，可能会造成代码通用性较差等情况，必须学会综合数据通用性、空间占用比、代码维护性 三点评估取舍因素权衡使用。
2.缓存穿透问题
缓存穿透是指查询一个一定不存在的数据，由于缓存不命中，并且出于容错考虑， 如果从存储层查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。
可能造成原因：
- 业务代码自身问题
- 恶意攻击。爬虫等等
危害
对底层数据源压力过大，有些底层数据源不具备高并发性。 例如mysql一般来说单台能够扛1000-QPS就已经很不错了
解决方案
1.缓存空对象
public class NullValueResultDO implements Serializable{
private static final long serialVersionUID = -6550539547145486005L;
}
public class UserManager {
UserDAO userDAO;
LocalCache localCache;
public UserDO getUser(String userNick) {
Object object = localCache.get(userNick);
if(object != null) {
if(object instanceof NullValueResultDO) {
return null;
}
return (UserDO)object;
} else {
User user = userDAO.getUser(userNick);
if(user != null) {
localCache.put(userNick,user);
} else {
localCache.put(userNick, new NullValueResultDO());
}
return user;
}
}
}2.布隆过滤器
使用Google guava
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>28.0-jre</version>
</dependency>public class TestBloomFilter {
/**
* 预估数据总量
*/
private static int size = 1000000;
/**
* 创建布隆过滤器，根据数据总量和容错率
*/
private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size, 0.01);
public static void main(String[] args) {
// 插入数据
for (int i = 0; i < size; i++) {
bloomFilter.put(i);
}
List<Integer> errorList = new ArrayList<Integer>();
// 故意取10000个不在过滤器里的值，看有多少个被认为在过滤器里
for (int i = size + 10000; i < size + 20000; i++) {
if (bloomFilter.mightContain(i)) {
errorList.add(i);
}
}
System.out.println("误判的数量：" + errorList.size());
}
}使用Redis实现布隆过滤器，利用bitmap
/**
* 判断keys是否存在于集合
*/
public boolean isExist(String key) {
long[] indexs = getIndexs(key);
List list = redisTemplate.executePipelined(new RedisCallback<Object>() {
@Nullable
@Override
public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
redisConnection.openPipeline();
for (long index : indexs) {
redisConnection.getBit("bf:taibai".getBytes(), index);
}
redisConnection.close();
return null;
}
});
return !list.contains(false);
}
/**
* 将key存入redis bitmap
*/
public void put(String key) {
long[] indexs = getIndexs(key);
redisTemplate.executePipelined(new RedisCallback<Object>() {
@Nullable
@Override
public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
redisConnection.openPipeline();
for (long index : indexs) {
redisConnection.setBit("bf:taibai".getBytes(),index,true);
}
redisConnection.close();
return null;
}
});
}3.缓存击穿.热点key重建缓存问题
缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力
我们知道，使用缓存，如果获取不到，才会去数据库里获取。但是如果是热点 key，访问量非常的大，数据库在重建缓存的时候，会出现很多线程同时重建的情况。因为高并发导致的大量热点的 key 在重建还没完成的时候，不断被重建缓存的过程，由于大量线程都去做重建缓存工作，导致服务器拖慢的情况。
解决方案
1.互斥锁
第一次获取缓存的时候，加一个锁，然后查询数据库，接着是重建缓存。这个时候，另外一个请求又过来获取缓存，发现有个锁，这个时候就去等待，之后都是一次等待的过程，直到重建完成以后，锁解除后再次获取缓存命中。
public String getKey(String key){
String value = redis.get(key);
if(value == null){
String mutexKey = "mutex:key:"+key; //设置互斥锁的key
if(redis.set(mutexKey,"1","ex 180","nx")){ //给这个key上一把锁，ex表示只有一个线程能执行，过期时间为180秒
value = db.get(key);
redis.set(key,value);
redis.delete(mutexKety);
}else{
// 其他的线程休息100毫秒后重试
Thread.sleep(100);
getKey(key);
}
}
return value;
}@Component
public class RedisLock implements Lock{
@Autowired
RedisTemplate redisTemplate;
private static final String KEYPREFIX="lock";
public static final String UNLOCK_LUA;
static {
StringBuilder sb = new StringBuilder();
sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
sb.append("then ");
sb.append(" return redis.call(\"del\",KEYS[1]) ");
sb.append("else ");
sb.append(" return 0 ");
sb.append("end ");
UNLOCK_LUA = sb.toString();
}
//ThreadLocal用于保存某个线程共享变量：对于同一个static ThreadLocal，不同线程只能从中get，set，remove自己的变量，而不会影响其他线程的变量
private static ThreadLocal<String> threadLocal=new ThreadLocal<>();
@Override
public void lock(String key) {
boolean b = tryLock(key);
if(b){
return;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock(key);
}
@Override
public boolean tryLock(String key) {
String uuid = UUID.randomUUID().toString();
RedisCallback<String> callback = (connection) -> {
JedisCommands commands = (JedisCommands) connection.getNativeConnection();
return commands.set(KEYPREFIX+key, uuid, "NX", "PX", 60000);
};
Object execute = redisTemplate.execute(callback);
if(execute!=null){
threadLocal.set(uuid);
return true;
}
return false;
}
@Override
public void unlock(String key) {
RedisCallback redisScript=new RedisCallback() {
@Nullable
@Override
public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
Object eval = redisConnection.eval(UNLOCK_LUA.getBytes(), ReturnType.fromJavaType(Long.class), 1, (KEYPREFIX + key).getBytes(), threadLocal.get().getBytes());
return eval;
}
};
redisTemplate.execute(redisScript);
}
}互斥锁的优点是思路非常简单，具有一致性，但是互斥锁也有一定的问题，就是大量线程在等待的问题。存在死锁的可能性。
2.redlock
4.缓存雪崩问题
缓存雪崩是指机器宕机或在我们设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩。
1：在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。
2：做二级缓存，A1为原始缓存，A2为拷贝缓存，A1失效时，可以访问A2，A1缓存失效时间设置为短期，A2设置为长期
3：不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。
4：如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
数据一致性
