Redis--大部分人不知道的缓存击穿与缓存设置顺序的操蛋事

发布时间:2020-08-08 21:39:22 作者:朱飞东
来源:网络 阅读:21723

一、关于缓存设置顺序:

cache,在web设计中经常用,大家也都会知道设置cache可以提高系统的响应速度,在做这个cache的时候,不知道为什么,很多人的流程都是:读取数据时,先从cache中读取数据,获取不到再去DB中获取,再将数据设置到cache中;更新数据时,先更新DB,成功之后再更新cache。在这里看似简单并没有什么问题,但是实际上,DB和cache理应是一个事务操作,要么同时失败,要么同时成功。
所以,往往会有以下的错误:

错误操作1:更新DB,同时写入cache 
eg:进程A写了cache,此时进程B打断了A,又写cache,并写了DB,再次轮到进程A继续写DB,
此时会导致,cache中保存的是B写入的数据,而DB中保存了A写入的数据,最终数据不一致,而且
这个cache一直都是脏数据,如果此时不断有进程来读取,都是存在的cache脏数据;同理,如果先
写DB,在写cache,一样存在可能被打断,最终导致cache是脏数据的问题

错误操作2,先删除cache,再更新DB,高并发时可能出现的问题:
eg:进程A先删除了cache,此时进程B打断A,则从DB中读取旧数据,并设置到了cache,再回来
进程A更新DB,那么从这里开始,接下去所有的读请求,都是旧cache,而且一直都是脏数据

正确的做法应该是:
1、读:先从DB读取之后,再写到cache中
2、更新:先更新 DB 中的数据,再删除 cache (必须是删除,而不是更新cache)
但是,这样一样不能保证不出错
eg:A进程读DB,B进程打断A,进行DB的更新,删除cache,再回来A进程写入到cache,一样
cache中是旧数据,而且一直是脏数据,但是,读数据库操作很快,写数据库操作比较慢,让一个慢
的操作打断快的相对概率比较低,所以采用这种方式,至于这里为什么是删除cache,而不是更新
cache,那是因为,如果A进程更新DB,此时B进程更新DB,同时更新cache,A进程再回来更新
cache,将会导致cache中的是脏数据

下面用代码来实现看看

def worker_read_type1(write_flag, user_workid):
        ''先从cache中读,获取不到,再从DB读取之后,再写到cache中''
        num = 0
        err_num = 0
        while True:
                redis_key = 't_users:'+str(user_workid)
                user_name = redis_db.get(redis_key)
                if not user_name:
                        sql = "select user_workid, user_name from t_users where user_workid={user_workid} limit 1".format(user_workid=user_workid)
                        data = mysql_extract_db.query_one_dict(sql=sql)
                        user_name = data.get('user_name', '')
                        redis_db.set(redis_key, user_name)
                num += 1
                if len(write_flag):
                        if user_name != write_flag[0]:
                                err_num += 1
                                print '出现不一致--user_name:{}---write_flag:{}, errpercent: err_num/num={}'.format(user_name, write_flag[0], str(float(err_num*100)/num)+'%')
                time.sleep(0.01)

    def worker_update_type1(write_flag, user_workid, user_name):
        "'先更新DB,然后更新cache'''
        while True:
                sql = "update t_users set user_name='{user_name}' where user_workid={user_workid} ".format(user_name=user_name, user_workid=user_workid)
                res = mysql_extract_db.execute_commit(sql=sql)
                write_flag[0] = user_name  #写入数据库后的值
                if res:
                        redis_key = 't_users:'+str(user_workid)
                        redis_db.set(redis_key, user_name)  #再更新cache
                time.sleep(0.01)

def worker_update_type2(write_flag, user_workid, user_name):
        ''
        先更新cache,再更新DB
        ''
        while True:
                redis_key = 't_users:'+str(user_workid)
                redis_db.set(redis_key, user_name)  #更新缓存
                sql = "update t_users set user_name='{user_name}' where user_workid={user_workid} ".format(user_name=user_name, user_workid=user_workid)
                res = mysql_extract_db.execute_commit(sql=sql)
                write_flag[0] = user_name  #写入数据库后的值
                time.sleep(0.01)

def worker_update_type3(write_flag, user_workid, user_name):
        ''
        先删除cache,再更新DB
        ''
        while True:
                redis_key = 't_users:'+str(user_workid)
                redis_db.delete(redis_key)  #删除缓存
                sql = "update t_users set user_name='{user_name}' where user_workid={user_workid} ".format(user_name=user_name, user_workid=user_workid)
                res = mysql_extract_db.execute_commit(sql=sql)
                write_flag[0] = user_name  #写入数据库后的值
                time.sleep(0.01)

def worker_update_type4(write_flag, user_workid, user_name):
        ''
        先更新DB,再删除cache
        ''
        while True:
                begin = time.time()
                sql = "update t_users set user_name='{user_name}' where user_workid={user_workid} ".format(user_name=user_name, user_workid=user_workid)
                res = mysql_extract_db.execute_commit(sql=sql)
                write_flag[0] = user_name  #写入数据库后的值
                if res:
                        redis_key = 't_users:'+str(user_workid)
                        redis_db.delete(redis_key)  #删除缓存
                time.sleep(0.01)

def test_check_run(read_nump=1, wri_nump=2, readfunc=None, wrifunc=None):
        "运行测试"
        write_flag = Manager().list()
        write_flag.append('1')
        for i in range(0, wri_nump):
                    p_write = Process(target=wrifunc, args=(write_flag, 2633,'RobotZhu'+str(random.randrange(1, 10000000))))
                p_write.start()
        for i in range(0, read_nump):
                p_read = Process(target=readfunc, args=(write_flag, 2633, ))
                p_read.start()
        print 'p is running'
        while True:
                pass            

#下面运行测试看看,一般来说,系统的读请求远远大于写请求,这里100个进程读,2个进程写
test_check_run(read_nump=100, wri_nump=2, readfunc=worker_read_type1, wrifunc=worker_update_type1)  #先更新DB,再更新cache,多进程写有问题
出现不一致--user_name:RobotZhu2038562---write_flag:RobotZhu669457, errpercent: err_num/num=11.4285714286%  出现数据不一致的情况概率是11.5%左右
test_check_run(read_nump=100, wri_nump=2, readfunc=worker_read_type1, wrifunc=worker_update_type2)  #先更新cache,再更新DB,多进程写有问题
出现不一致--user_name:RobotZhu4607997---write_flag:RobotZhu8633737, errpercent: err_num/num=53.8461538462% 出现数据不一致的情况概率是50%左右
test_check_run(read_nump=100, wri_nump=2, readfunc=worker_read_type1, wrifunc=worker_update_type3)  #先删除cache,再更新DB,读进程打断写进程时有严重问题
出现不一致--user_name:RobotZhu2034159---write_flag:RobotZhu4882794, errpercent: err_num/num=23.9436619718%  不一致概率20%多
test_check_run(read_nump=100, wri_nump=2, readfunc=worker_read_type1, wrifunc=worker_update_type4)  #先更新DB,再删除cache,写进程打断读进程是有问题
出现不一致--user_name:RobotZhu1536990---write_flag:RobotZhu1536990, errpercent: err_num/num=7.69230769231%  数据不一致概率7%左右,所以这个比较好

二、缓存“击穿”处理:

一个设置了过期时间的cache,在它过期那一刻,大量的并发请求会直连DB,DB负载过重问题。

解决办法:
1、当获取数据发现为空时,说明cache过期了,此时不马上连接DB,而是类似redis中的SETNX语
法,设置一个tempkey=1,如果这个tempkey存在,则设置失败,不存在则设置成功, 设置成功,则
进行DB读取数据,写入cache,否则延时30s,再次重试读cache,可能就有数据了。为什么这么
做?因为多进程并发的时候,第一个发现cache失效了,设置了tempkey,进行DB读数据,其他进程
则因为无法设置tempkey而等待一会,再读数据。
代码示例:
def get_data(key=None):
  value = redis.get(key)
  if not value:
      #缓存失效
      if 1==redis.setnx(key+'tempkey', 1, 60):   #设置一个临时key,如果被其他进程设置过了,则设置失败,也就不会连接db
          value = db.query('select name from test')
          redis.set(key, value)
          redis.delete(key+'tempkey')
     else:
         time.sleep(10)
         get_data(key)  #递归重试,或许已经可以直接从cache中获取了
 else:
     return value
推荐阅读:
  1. redis缓存穿透,缓存击穿,缓存雪崩原因+解决方案
  2. 缓存穿透,缓存击穿,缓存雪崩解决方案分析

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

缓存击穿 缓存 设置原则

上一篇:Oracle Data Guard Feature 12cR2系列(二)

下一篇:社交新零售品牌运营必须知道的几点

相关阅读

您好,登录后才能下订单哦!

密码登录
登录注册
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》