Redis原理和高可用场景实践总结(三)

本文涉及的产品
云数据库 Redis 版,社区版 2GB
推荐场景:
搭建游戏排行榜
简介: Redis原理和高可用场景实践总结

Redis分布式锁实现原理

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * 分布式锁
 * 性能待测试
 * @author lzhcode
 *
 */
public class RedisLock {
    private static Logger logger = LoggerFactory.getLogger(RedisLock.class);
      private RedisTemplate redisTemplate;
      private static final int DEFAULT_ACQUIRY_RESOLUTION_MILLIS = 100;
      /**
       * Lock key path.
       */
      private String lockKey;
      /**
       * 锁超时时间,防止线程在入锁以后,无限的执行等待
       */
      private int expireMsecs = 60 * 1000;
      /**
       * 锁等待时间,防止线程饥饿
       */
      private int timeoutMsecs = 10 * 1000;
      private volatile boolean locked = false;
      /**
       * Detailed constructor with default acquire timeout 10000 msecs and lock expiration of 60000 msecs.
       *
       * @param lockKey lock key (ex. account:1, ...)
       */
      public RedisLock(RedisTemplate redisTemplate, String lockKey) {
          this.redisTemplate = redisTemplate;
          this.lockKey = lockKey + "_lock";
      }
      /**
       * Detailed constructor with default lock expiration of 60000 msecs.
       *
       */
      public RedisLock(RedisTemplate redisTemplate, String lockKey, int timeoutMsecs) {
          this(redisTemplate, lockKey);
          this.timeoutMsecs = timeoutMsecs;
      }
      /**
       * Detailed constructor.
       *
       */
      public RedisLock(RedisTemplate redisTemplate, String lockKey, int timeoutMsecs, int expireMsecs) {
          this(redisTemplate, lockKey, timeoutMsecs);
          this.expireMsecs = expireMsecs;
      }
      /**
       * @return lock key
       */
      public String getLockKey() {
          return lockKey;
      }
      private String get(final String key) {
          Object obj = null;
          try {
              obj = redisTemplate.execute(new RedisCallback<Object>() {
                  @Override
                  public Object doInRedis(RedisConnection connection) throws DataAccessException {
                      StringRedisSerializer serializer = new StringRedisSerializer();
                      byte[] data = connection.get(serializer.serialize(key));
                      connection.close();
                      if (data == null) {
                          return null;
                      }
                      return serializer.deserialize(data);
                  }
              });
          } catch (Exception e) {
              logger.error("get redis error, key : {}", key);
          }
          return obj != null ? obj.toString() : null;
      }
      private boolean setNX(final String key, final String value) {
          Object obj = null;
          try {
              obj = redisTemplate.execute(new RedisCallback<Object>() {
                  @Override
                  public Object doInRedis(RedisConnection connection) throws DataAccessException {
                      StringRedisSerializer serializer = new StringRedisSerializer();
                      Boolean success = connection.setNX(serializer.serialize(key), serializer.serialize(value));
                      connection.close();
                      return success;
                  }
              });
          } catch (Exception e) {
              logger.error("setNX redis error, key : {}", key);
          }
          return obj != null ? (Boolean) obj : false;
      }
      private String getSet(final String key, final String value) {
          Object obj = null;
          try {
              obj = redisTemplate.execute(new RedisCallback<Object>() {
                  @Override
                  public Object doInRedis(RedisConnection connection) throws DataAccessException {
                      StringRedisSerializer serializer = new StringRedisSerializer();
                      byte[] ret = connection.getSet(serializer.serialize(key), serializer.serialize(value));
                      connection.close();
                      return serializer.deserialize(ret);
                  }
              });
          } catch (Exception e) {
              logger.error("setNX redis error, key : {}", key);
          }
          return obj != null ? (String) obj : null;
      }
      /**
       * 获得 lock.
       * 实现思路: 主要是使用了redis 的setnx命令,缓存了锁.
       * reids缓存的key是锁的key,所有的共享, value是锁的到期时间(注意:这里把过期时间放在value了,没有时间上设置其超时时间)
       * 执行过程:
       * 1.通过setnx尝试设置某个key的值,成功(当前没有这个锁)则返回,成功获得锁
       * 2.锁已经存在则获取锁的到期时间,和当前时间比较,超时的话,则设置新的值
       *
       * @return true if lock is acquired, false acquire timeouted
       * @throws InterruptedException in case of thread interruption
       */
      public   boolean lock() throws InterruptedException {
          int timeout = timeoutMsecs;
          while (timeout >= 0) {
              long expires = System.currentTimeMillis() + expireMsecs + 1;
              String expiresStr = String.valueOf(expires); //锁到期时间
              if (this.setNX(lockKey, expiresStr)) {
                  // lock acquired
                  locked = true;
                  return true;
              }
              String currentValueStr = this.get(lockKey); //redis里的时间
              if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
                  //判断是否为空,不为空的情况下,如果被其他线程设置了值,则第二个条件判断是过不去的
                  // lock is expired
                  String oldValueStr = this.getSet(lockKey, expiresStr);
                  //获取上一个锁到期时间,并设置现在的锁到期时间,
                  //只有一个线程才能获取上一个线上的设置时间,因为jedis.getSet是同步的
                  if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
                      //防止误删(覆盖,因为key是相同的)了他人的锁——这里达不到效果,这里值会被覆盖,但是因为什么相差了很少的时间,所以可以接受
                      //[分布式的情况下]:如过这个时候,多个线程恰好都到了这里,但是只有一个线程的设置值和当前值相同,他才有权利获取锁
                      // lock acquired
                      locked = true;
                      return true;
                  }
              }
              timeout -= DEFAULT_ACQUIRY_RESOLUTION_MILLIS;
              /*
                  延迟100 毫秒,  这里使用随机时间可能会好一点,可以防止饥饿进程的出现,即,当同时到达多个进程,
                  只会有一个进程获得锁,其他的都用同样的频率进行尝试,后面有来了一些进行,也以同样的频率申请锁,这将可能导致前面来的锁得不到满足.
                  使用随机的等待时间可以一定程度上保证公平性
               */
              Thread.sleep(DEFAULT_ACQUIRY_RESOLUTION_MILLIS);
          }
          return false;
      }
      /**
       * Acqurired lock release.
       */
      public   void unlock() {
          if (locked) {
              redisTemplate.delete(lockKey);
              locked = false;
          }
      }
}

和RedisLock和Redisson表面来看,这个方案似乎很管用,但是这里存在一个问题:在我们的系统架构里存在一个单点故障,如果Redis的master节点宕机了怎么办呢?有人可能会说:加一个slave节点!在master宕机时用slave就行了!但是其实这个方案明显是不可行的,因为这种方案无法保证第1个安全互斥属性,因为Redis的复制是异步的。 总的来说,这个方案里有一个明显的竞争条件(race condition),举例来说:

  • 客户端A在master节点拿到了锁。
  • master节点在把A创建的key写入slave之前宕机了。
  • slave变成了master节点
  • B也得到了和A还持有的相同的锁(因为原来的slave里还没有A持有锁的信息)

下面的表格总结了Zookeeper和Redis分布式锁的优缺点:

15、你们生产环境中的redis是怎么部署的

redis cluster,10台机器,5台机器部署了redis主实例,另外5台机器部署了redis的从实例,每个主实例挂了一个从实例,5个节点对外提供读写服务,每个节点的读写高峰qps可能可以达到每秒5万,5台机器最多是25万读写请求/s。

机器是什么配置?32G内存+8核CPU+1T磁盘,但是分配给redis进程的是10g内存,一般线上生产环境,redis的内存尽量不要超过10g,超过10g可能会有问题。

5台机器对外提供读写,一共有50g内存。

因为每个主实例都挂了一个从实例,所以是高可用的,任何一个主实例宕机,都会自动故障迁移,redis从实例会自动变成主实例继续提供读写服务

你往内存里写的是什么数据?每条数据的大小是多少?商品数据,每条数据是10kb。100条数据是1mb,10万条数据是1g。常驻内存的是200万条商品数据,占用内存是20g,仅仅不到总内存的50%。

目前高峰期每秒就是3500左右的请求量

16、Redis Java客户端的选择

Redis的Java客户端很多,官方推荐的有三种:Jedis、Redisson和lettuce。

在这里对Jedis和Redisson进行对比介绍

Jedis:

轻量,简洁,便于集成和改造

支持连接池

支持pipelining、事务、LUA Scripting、Redis Sentinel、Redis Cluster

不支持读写分离,需要自己实现

文档差(真的很差,几乎没有……)

Redisson:

基于Netty实现,采用非阻塞IO,性能高

支持异步请求

支持连接池

支持pipelining、LUA Scripting、Redis Sentinel、Redis Cluster

不支持事务,官方建议以LUA Scripting代替事务

支持在Redis Cluster架构下使用pipelining

支持读写分离,支持读负载均衡,在主从复制和Redis Cluster架构下都可以使用

内建Tomcat Session Manager,为Tomcat 6/7/8提供了会话共享功能

可以与Spring Session集成,实现基于Redis的会话共享

文档较丰富,有中文文档

17、保护模式

Redis从3.2开始加强安全管理,如果redis没有设置密码,那么redis客户端只能从本地进行访问,如果是从其他机器连接过来访问的,就会报错误。

解决方案是设置参数protected-mode no,这个参数可以动态设置,或者为redis设置密码。

redis-cli -p 6500 config set protected-mode no

18、防重复提交

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DuplicateSubmit {
}
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;
@Aspect
@Component
@Order(-2)
@Slf4j
public class DuplicateSubmitInteceptor {
    @Autowired
    private RedisUtils redisDomainService;
    @Pointcut("within(com.controller..*)")
    public void doubleCheckCut() {
    }
    @Around("doubleCheckCut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Method method = ((MethodSignature) pjp.getSignature()).getMethod();
        DuplicateSubmit duplicateSubmit = method.getAnnotation(DuplicateSubmit.class);
        if (null != duplicateSubmit) {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            String uri = request.getRequestURI();
            Long orgId = UserContextHolder.getUser().getUserId();
            if (null == orgId) {
                throw new ServerException(ErrorCode.USER_INFO_ERROR);
            }
            String value = Long.toString(System.currentTimeMillis());
            try {
                boolean dobuleCheck =
                        redisDomainService.setIfAbsent(String.format(RedisKeyEnum.DOUBLE_REQUEST.getCode(), uri, orgId),
                                value,
                                RedisKeyEnum.DOUBLE_REQUEST.getTime().intValue(), TimeUnit.SECONDS);
                if (!dobuleCheck) {
                    log.error("======>表单重复提交限制出错...{}");
                    throw new ServerException(ErrorCode.DOUBLE_REQUEST_ERROR);
                }
                Object proceed = pjp.proceed();
                return proceed;
            } catch (Exception e) {
                log.error("======>表单重复提交限制出错...{}", e);
                throw e;
            } finally {
                String o = redisDomainService.getString(String.format(RedisKeyEnum.DOUBLE_REQUEST.getCode(), uri,
                        orgId));
                if (null != o) {
                    redisDomainService.unlock(String.format(RedisKeyEnum.DOUBLE_REQUEST.getCode(), uri, orgId), value);
                }
            }
        }
        return pjp.proceed();
    }
}

19、Redis有哪些淘汰策略

LFU (Least Frequently Used) :最近最少使用,跟使用的次数有关,淘汰使用次数最少的。

LRU (Least Recently Used): 最近最不经常使用,跟使用的最后一次时间有关,淘汰最近使用时间离现在最久的。

  • noevction:一旦缓存被写满了,再有写请求来时,Redis 不再提供服务,而是直接返回错误。Redis 用作缓存时,实际的数据集通常都是大于缓存容量的,总会有新的数据要写入缓存,这个策略本身不淘汰数据,也就不会腾出新的缓存空间,我们不把它用在 Redis 缓存中。
  • volatile-ttl 在筛选时,会针对设置了过期时间的键值对,根据过期时间的先后进行删除,越早过期的越先被删除。
  • volatile-random 就像它的名称一样,在设置了过期时间的键值对中,进行随机删除。
  • volatile-lru 会使用 LRU 算法筛选设置了过期时间的键值对。
  • volatile-lfu 会使用 LFU 算法选择设置了过期时间的键值对。
  • allkeys-random 策略,从所有键值对中随机选择并删除数据。
  • allkeys-lru 策略,使用 LRU 算法在所有数据中进行筛选。
  • allkeys-lfu 策略,使用 LFU 算法在所有数据中进行筛选。
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务,基于高可靠双机热备架构及可无缝扩展的集群架构,满足高读写性能场景及容量需弹性变配的业务需求。 产品详情:https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&amp;RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
相关文章
|
8天前
|
存储 消息中间件 缓存
Redis的高性能使得它非常适合用于实时分析场景
【5月更文挑战第15天】Redis在Python Web开发中扮演关键角色,常用于缓存系统,提高数据读取速度;会话管理,存储用户信息;分布式锁,确保数据一致性;排行榜和计数,利用有序集合和哈希结构;消息队列,基于列表结构实现异步处理;实时分析,高效处理实时数据。其丰富的数据结构和高性能使其在多种场景下应用广泛。
284 3
|
5天前
|
存储 缓存 NoSQL
由菜鸟到大神,谈谈redis的概念、实战、原理、高级使用方法
【5月更文挑战第18天】Redis是一个开源的内存中的数据结构存储系统,它可以用作数据库、缓存和消息中间件。它支持多种类型的数据结构,如字符串、哈希、列表、集合、有序集合等。
22 10
|
8天前
|
负载均衡 NoSQL 关系型数据库
深入浅出Redis(六):Redis的主从架构与主从复制原理
深入浅出Redis(六):Redis的主从架构与主从复制原理
|
8天前
|
存储 监控 NoSQL
Redis是如何保证高可用的?
通过这些机制,Redis可以在主节点故障或其他异常情况下保持高可用性,确保数据的可靠性和可用性。不过,为了实现高可用性,需要仔细规划和配置Redis集群,并确保监控和故障恢复机制的可靠性。
25 6
|
8天前
|
监控 NoSQL 算法
深入剖析Redis哨兵模式的原理和应用
Redis的哨兵模式是实现高可用性和自动故障转移的机制,当主服务器故障时,哨兵能自动检测并进行故障转移,确保服务连续和稳定性。哨兵模式通过监控主从服务器状态、自动故障转移、防止数据不一致,提高容错能力和负载均衡,降低运维成本,实现高可用性。哨兵通过检测主观下线和客观下线状态,以及选举Leader Sentinel来协调故障转移。Raft算法在其中用于领导者选举和状态一致性。哨兵模式通过综合考虑多种因素选举新主服务器并执行故障转移,保障集群稳定运行。
100 0
深入剖析Redis哨兵模式的原理和应用
|
8天前
|
存储 负载均衡 监控
Redis分区指南:如何实现高可用与扩展性
本文由技术小伙伴小米讲解Redis分区容错中的数据分区。内容涉及Hash、一致性Hash、Codis的Hash槽和RedisCluster四种方法。Hash简单但不稳定,数据迁移和分区不均衡是其主要问题;一致性Hash通过最小化数据迁移实现负载均衡,但仍有局限;Codis的Hash槽提供灵活的负载均衡和在线迁移;RedisCluster是官方高可用、可扩展的解决方案。每种方案有优缺点,需根据实际需求选择。
106 0
Redis分区指南:如何实现高可用与扩展性
|
8天前
|
NoSQL Redis
Redis入门到通关之Redis主从数据同步原理
Redis入门到通关之Redis主从数据同步原理
31 0
|
8天前
|
存储 NoSQL Redis
Redis入门到通关之Redission原理
Redis入门到通关之Redission原理
25 0
|
8天前
|
负载均衡 监控 NoSQL
Redis的几种主要集群方案
【5月更文挑战第15天】Redis集群方案包括主从复制(基础,读写分离,手动故障恢复)、哨兵模式(自动高可用,自动故障转移)和Redis Cluster(官方分布式解决方案,自动分片、容错和扩展)。此外,还有Codis、Redisson和Twemproxy等工具用于代理分片和负载均衡。选择方案需考虑应用场景、数据量和并发需求,权衡可用性、性能和扩展性。
181 2