缓存几大问题
缓存击穿 —》分布式锁 问题:数据刚好失效(缓存当中没有这条),此时来了并发访问;
缓存穿透 —》缓存控对象,布隆过滤器 问题:查询缓存和数据库当中都没有的数据;
缓存雪崩 —》搭建高可用集群,错开缓存失效时间 问题:大部分数据失效(机器宕机)。
一、缓存粒度控制
通俗来讲,缓存粒度问题就是我们在使用缓存时,是将所有数据缓存还是缓存部分数据?
缓存粒度问题是一个容易被忽视的问题,如果使用不当,可能会造成很多无用空间的浪费,可能会造成网络带宽的浪费,可能会造成代码通用性较差等情况,必须学会综合数据通用性、空间占用比、代码维护性 三点评估取舍因素权衡使用。
二、缓存穿透问题
缓存穿透是指查询一个一定不存在的数据,由于缓存不命中,并且出于容错考虑, 如果从存储层查不到数据则不写入缓存,这将导致这个不存在的数据每次请求都要到存储层去查询,失去了缓存的意义。
- 1、可能造成原因:
1)业务代码自身问题
2)恶意攻击。爬虫等等
- 2、危害
对底层数据源压力过大,有些底层数据源不具备高并发性。 例如mysql一般来说单台能够扛1000-QPS就已经很不错了
- 3、解决方案
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)布隆过滤器
(1)Google布隆过滤器的缺点
基于JVM内存的一种布隆过滤器
重启即失效
本地内存无法用在分布式场景
不支持大数据量存储
(2)、Redis布隆过滤器
可扩展性Bloom过滤器:一旦Bloom过滤器达到容量,就会在其上创建一个新的过滤器
不存在重启即失效或者定时任务维护的成本:基于Google实现的布隆过滤器需要启动之后初始化布隆过滤器
缺点:需要网络IO,性能比Google布隆过滤器低
三、缓存击穿.热点key重建缓存问题
缓存击穿是指缓存中没有但数据库中有的数据(一般是缓存时间到期),这时由于并发用户特别多,同时读缓存没读到数据,又同时去数据库去取数据,引起数据库压力瞬间增大,造成过大压力。
我们知道,使用缓存,如果获取不到,才会去数据库里获取。但是如果是热点 key,访问量非常的大,数据库在重建缓存的时候,会出现很多线程同时重建的情况。因为高并发导致的大量热点的 key 在重建还没完成的时候,不断被重建缓存的过程,由于大量线程都去做重建缓存工作,导致服务器拖慢的情况。
解决方案:
1.使用setnx
setnx key value 只有在 key 不存在时设置 key 的值。
因为可能存在获取到锁的业务突然挂掉了,那么nx锁永远无法释放,那么很容易造成死锁,
故需要设置一个过期时间,时间到了,就会自动释放锁;而且nx和ex不能分开写,保证原子性。
@Test
public void testRedis(){
Jedis jedis=new Jedis("111.111.111.94",6379);
jedis.auth("123456");
SetParams setParams=new SetParams();
setParams.ex(6); //setex 设置值的同时设置过期时间
setParams.nx(); //
String s = UUID.randomUUID().toString();
String lock = jedis.set("lock", s,setParams);
// Long setnx = jedis.setnx("lock", "value2");
// if(setnx==1){
// jedis.expire("lock",10);
// }
System.out.println(lock);
}
- 2.互斥锁
第一次获取缓存的时候,加一个锁,然后查询数据库,接着是重建缓存。这个时候,另外一个请求又过来获取缓存,发现有个锁,这个时候就去等待,之后都是一次等待的过程,直到重建完成以后,锁解除后再次获取缓存命中。
SET KEY VALUE [EX seconds] [PX milliseconds] [NX|XX]
EX seconds − 设置指定的到期时间(以秒为单位)。
PX milliseconds - 设置指定的到期时间(以毫秒为单位)。
NX - 仅在键不存在时设置键。
XX - 只有在键已存在时才设置。
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;
}
互斥锁的优点是思路非常简单,具有一致性,但是互斥锁也有一定的问题,就是大量线程在等待的问题。存在死锁的可能性。
- 3、分布式锁 redisson
具体查看网页 redisson分布式锁
- 3、分布式锁 自己写普通锁
@Component
public class RedisLock implements Lock {
@Autowired
private JedisPool jedisPool;
private static final String key="lock";
private ThreadLocal<String> threadLocal=new ThreadLocal<>();
private static AtomicBoolean isHappened = new AtomicBoolean(true);
//加锁
@Override
public void lock() {
boolean b = tryLock(); //尝试加锁
if(b){
//拿到了锁
return;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock();
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
//尝试加锁
@Override
public boolean tryLock() {
SetParams setParams=new SetParams();
setParams.ex(2); //2s
setParams.nx();
String s = UUID.randomUUID().toString();
Jedis resource = jedisPool.getResource();
String lock = resource.set(key, s,setParams);
// String lock = resource.set(key,s,"NX","PX",5000);
resource.close();
if("OK".equals(lock)){
//拿到了锁
threadLocal.set(s);
if(isHappened.get()){
ThreadUtil.newThread(new MyRUnble(jedisPool)).start();
isHappened.set(false);
}
return true;
}
return false;
}
static class MyRUnble implements Runnable{
private JedisPool jedisPool;
public MyRUnble(JedisPool jedisPool){
this.jedisPool=jedisPool;
}
@Override
public void run() {
Jedis jedis = jedisPool.getResource();
while (true){
Long ttl = jedis.ttl(key);
if(ttl!=null && ttl>0){
jedis.expire(key, (int) (ttl+1));
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
//第一步判断设置时候的value 和 此时redis的value是否相同
//解锁
@Override
public void unlock() throws Exception{
String script="if redis.call(\"get\",KEYS[1])==ARGV[1] then\n" +
" return redis.call(\"del\",KEYS[1])\n" +
"else\n" +
" return 0\n" +
"end";
Jedis resource = jedisPool.getResource();
resource.del(key);
// Object eval = resource.eval(script, Arrays.asList(key), Arrays.asList(threadLocal.get()));
// if(Integer.valueOf(eval.toString())==0){
// resource.close();
// throw new Exception("解锁失败");
// }
resource.close();
}
@Override
public Condition newCondition() {
return null;
}
}
四、缓存雪崩问题
缓存雪崩是指机器宕机或在我们设置缓存时采用了相同的过期时间,导致缓存在某一时刻同时失效,请求全部转发到DB,DB瞬时压力过重雪崩。
解决办法:高可用集群
1:在缓存失效后,通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存,其他线程等待。
2:做二级缓存,A1为原始缓存,A2为拷贝缓存,A1失效时,可以访问A2,A1缓存失效时间设置为短期,A2设置为长期
3:不同的key,设置不同的过期时间,让缓存失效的时间点尽量均匀。
4:如果缓存数据库是分布式部署,将热点数据均匀分布在不同搞得缓存数据库中。
以上信息来我在鲁班学院学习的总结,鲁班学院很不错,值得报班