「查缺补漏」巩固你的 Redis 知识体系

用户头像
Kerwin
关注
发布于: 2020 年 08 月 06 日
「查缺补漏」巩固你的Redis知识体系

Windows Redis



安装



链接: https://pan.baidu.com/s/1MJnzX_qRuNXJI09euzkPGA 提取码: 2c6w 复制这段内容后打开百度网盘手机App,操作更方便哦



无脑下一步即可



使用



出现错误:



creating server tcp listening socket 127.0.0.1:6379: bind No error



解决方案:



  1. redis-cli.exe

  2. shutdown

  3. exit

  4. redis-server.exe redis.windows.conf



启动:redis-server.exe redis.windows.conf



客户端启动:redis-cli.exe (不修改配置的话默认即可)



​ redis-cli.exe -h 127.0.0.1 -p 6379 -a password



基本文件说明



| 可执行文件 | 作用说明 |

| ---------------- | --------------------------- |

| redis-server | redis服务 |

| redis-cli | redis命令行工具 |

| redis-benchmark | 基准性能测试工具 |

| redis-check-aof | AOF持久化文件检测和修复工具 |

| redis-check-dump | RDB持久化文件检测和修复工具 |

| redis-sentinel | 启动哨兵 |

| redis-trib | cluster集群构建工具 |



基础命令



| 命令 | 说明 |

| ----------------- | :------------------------------------------------------- |

| keys | redis允许模糊查询key  有3个通配符 、?、[] |

| del key | 删除key |

| exists kxm | 判断是否存在 |

| expire key 20 | 设置过期时间 - 秒 |

| pexpire key 20000 | 设置过期时间 - 毫秒 |

| move kxm 2 | 移动key到指定位置库中 2号库 |

| persist key | 移除过期时间,key将会永久存在 成功设置返回1 否则返回0 |

| pttl key | 以毫秒为单位返回 key 的剩余的过期时间 |

| ttl key | 以秒为单位,返回给定 key 的剩余生存时间 |

| randomkey | 从当前数据库中随机返回一个 key |

| rename key newkxy | 更改key的名字,如果重复了会覆盖 |

| renamenx kxm key | 仅当 newkey 不存在时,将 key 改名为 newkey |

| type key | 返回 key 所储存的值的类型 |

| select 0 | 选择第一个库 |

| ping | 返回PONG 表示连接正常 |

| quit | 关闭当前连接 |





字符串命令



| 命令 | 说明 |

| ------------------------------ | ------------------------------------------------------------ |

| set key aaa | 设置指定 key 的值 |

| get key | 获取指定 key 的值 |

| getrange key 0 1 | 返回 key 中字符串值的子字符 包含 0 和 1 包含关系 |

| getset key aaaaaaaa | 将给定 key 的值设为 value ,并返回 key 的旧值(old value) |

| mget key kxm | 获取所有(一个或多个)给定 key 的值 |

| setex test 5 "this is my test" | 将值 value 关联到 key ,并将 key 的过期时间设为 seconds (以秒为单位) |

| setnx test test | 只有在 key 不存在时设置 key 的值 (用于分布式锁) |

| strlen test | 返回 key 所储存的字符串值的长度 |

| mset key1 "1" key2 "2" | 同时设置一个或多个 key-value 对 |

| msetnx key3 "a" key2 "b" | 同时设置一个或多个 key-value 对,当且仅当所有给定 key 都不存在 其中一个失败则全部失败 |

| incr key | 将 key 中储存的数字值增一 -> key的值 比如为 数字类型字符串 返回增加后的结果 |

| incrby num 1000 | 将 key 中储存的数字值增指定的值 -> key的值 比如为 数字类型字符串 返回增加后的结果 |

| decr key | 同 -> 减一 |

| decrby num 500 | 同 -> 减指定值 |

| append key 1123123 | 如果 key 已经存在并且是一个字符串, APPEND 命令将指定的 value 追加到该 key 原来值(value)的末尾 返回字符串长度 |



哈希(Hash)命令



| 命令 | 说明 |

| ---------------------------------- | --------------------------------------------------- |

| hdel key field1 [field2] | 删除一个或多个哈希表字段 |

| hexistskey field | 查看哈希表 key 中,指定的字段是否存在 |

| hget key field | 获取存储在哈希表中指定字段的值 |

| hgetall key | 获取在哈希表中指定 key 的所有字段和值 |

| hincrby hash yeary 1 | 为哈希表 key 中的指定字段的整数值加上增量 increment |

| hkeys hash | 获取所有哈希表中的字段 |

| hlen hash | 获取哈希表中字段的数量 |

| hmget hash name year | 获取所有给定字段的值 |

| hmset hash name "i am kxm" year 24 | 同时将多个 field-value (域-值)对设置到哈希表 key 中 |

| hset hash name kxm | 将哈希表 key 中的字段 field 的值设为 value |

| hsetnx key field value | 只有在字段 field 不存在时,设置哈希表字段的值 |

| hvals hash | 获取哈希表中所有值 |

| hexists hash name | 是否存在 |



编码: field value 值由 ziplist 及 hashtable 两种编码格式

>

字段较少的时候采用ziplist,字段较多的时候会变成hashtable编码



列表(List)命令



Redis列表是简单的字符串列表,按照插入顺序排序。你可以添加一个元素到列表的头部(左边)或者尾部(右边)



一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)



容量 -> 集合,有序集合也是如此



| 命令 | 说明 |

| ---------------------------- | ------------------------------------------------------------ |

| lpush list php | 将一个值插入到列表头部 返回列表长度 |

| lindex list 0 | 通过索引获取列表中的元素 |

| blpop key1 [key2 ] timeout | 移出并获取列表的第一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止 |

| brpop key1 [key2 ] timeout | 移出并获取列表的最后一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止 |

| linsert list before 3 4 | 在值 3 前插入 4 前即为顶 |

| linsert list after 4 5 | 在值4 后插入5 |

| llen list | 获取列表长度 |

| lpop list | 移出并获取列表的第一个元素 |

| lpush list c++ c | 将一个或多个值插入到列表头部 |

| lrange list 0 1 | 获取列表指定范围内的元素 包含0和1 -1 代表所有 (lrange list 0 -1) |

| lrem list 1 c | 移除list 集合中 值为 c 的 一个元素, 1 代表count 即移除几个 |

| lset list 0 "this is update" | 通过索引设置列表元素的值 |

| ltrim list 1 5 | 对一个列表进行修剪(trim),就是说,让列表只保留指定区间内的元素,不在指定区间之内的元素都将被删除 |

| rpop list | 移除列表的最后一个元素,返回值为移除的元素 |

| rpush list newvalue3 | 从底部添加新值 |

| rpoplpush list list2 | 转移列表的数据 |



集合(Set)命令



Set 是 String 类型的无序集合。集合成员是唯一的,这就意味着集合中不能出现重复的数据



| 命令 | 说明 |

| ------------------------------------------------------------ | --------------------------------------------------- |

| sadd set java php c c++ python | 向集合添加一个或多个成员 |

| scard set | 获取集合的成员数 |

| sdiff key1 [key2] | 返回给定所有集合的差集 数学含义差集 |

| sdiffstore curr set newset (sdiffstore destination key1 [key2]) | 把set和 newset的差值存储到curr中 |

| sinter set newset | 返回给定所有集合的交集 |

| sinterstore curr set newset (sinterstoredestination key1 [key2]) | 同 |

| sismember set c# | 判断 member 元素是否是集合 key 的成员 |

| smembers set | 返回集合中的所有成员 |

| srandmember set 2 | 随机抽取两个key (抽奖实现美滋滋) |

| smove set newtest java (smove source destination member) | 将 member 元素从 source 集合移动到 destination 集合 |

| sunion set newset | 返回所有给定集合的并集 |

| srem set java | 删除 |

| spop set | 从集合中弹出一个元素 |

| sdiff \| sinter \| sunion | 操作:集合间运算:差集 |



有序集合(sorted set)命令



Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。



不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。



有序集合的成员是唯一的,但分数(score)却可以重复。



| 命令 | 说明 |

| -------------------------------- | ------------------------------------------------------------ |

| zadd sort 1 java 2 python | 向有序集合添加一个或多个成员,或者更新已存在成员的分数 |

| zcard sort | 获取有序集合的成员数 |

| zcount sort 0 1 | 计算在有序集合中指定区间分数的成员数 |

| zincrby sort 500 java | 有序集合中对指定成员的分数加上增量 increment |

| zscore sort java | 返回有序集中,成员的分数值 |

| zrange sort 0 -1 | 获取指定序号的值,-1代表全部 |

| zrangebyscore sort 0 5 | 分数符合范围的值 |

| zrangebyscore sort 0 5 limit 0 1 | 分页 limit 0代表页码,1代表每页显示数量 |

| zrem sort java | 移除元素 |

| zremrangebyrank sort 0 1 | 按照排名范围删除元素 |

| zremrangebyscore sort 0 1 | 按照分数范围删除元素 |

| zrevrank sort c# | 返回有序集合中指定成员的排名,有序集成员按分数值递减(从大到小)排序 |



发布订阅



开启两个客户端



A客户端订阅频道: subscribe redisChat (频道名字为 redisChat)



B客户端发布内容: publish redisChat "Hello, this is my wor" (内容是 hello....)



A客户端即为自动收到内容, 原理图如下:







| 命令 | 说明 |

| ------------------- | --------------------------- |

| pubsub channels | 查看当前redis 有多少个频道 |

| pubsub numsub chat1 | 查看某个频道的订阅者数量 |

| unsubscrible chat1 | 退订指定频道 |

| psubscribe java.* | 订阅一组频道 |





Redis 事务



Redis 事务可以一次执行多个命令, 并且带有以下三个重要的保证:



  • 批量操作在发送 EXEC 命令前被放入队列缓存

  • 收到 EXEC 命令后进入事务执行,事务中任意命令执行失败,其余的命令依然被执行

  • 在事务执行过程,其他客户端提交的命令请求不会插入到事务执行命令序列中



一个事务从开始到执行会经历以下三个阶段:



  • 开始事务

  • 命令入队

  • 执行事务



``注意:redis事务和数据库事务不同,redis事务出错后最大的特点是,一剩下的命令会继续执行,二出错的数据不会回滚``



| 命令 | 说明 |

| --------- | ------------------------------------------------------------ |

| multi | 标记一个事务开始 |

| exec | 执行事务 |

| discard | 事务开始后输入命令入队过程中,中止事务 |

| watch key | 监视一个(或多个) key ,如果在事务执行之前这个(或这些) key 被其他命令所改动,那么事务将被打断 |

| unwatch | 取消 WATCH 命令对所有 key 的监视 |



Redis 服务器命令



| 命令 | 说明 |

| -------- | ----------------------- |

| flushall | 删除所有数据库的所有key |

| flushdb | 删除当前数据库的所有key |

| save | 同步保存数据到硬盘 |



Redis 数据备份与恢复



Redis SAVE 命令用于创建当前数据库的备份



如果需要恢复数据,只需将备份文件 (dump.rdb) 移动到 redis 安装目录并启动服务即可。获取 redis 目录可以使用 CONFIG 命令



Redis 性能测试



redis 性能测试的基本命令如下:



redis目录执行:redis-benchmark [option] [option value]

// 会返回各种操作的性能报告(100连接,10000请求)
redis-benchmark -h 127.0.0.1 -p 6379 -c 100 -n 10000

// 100个字节作为value值进行压测
redis-benchmark -h 127.0.0.1 -p 6379 -q -d 100




Java Redis



Jedis



<!-- jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.8.2</version>
</dependency>



Jedis配置



############# redis Config #############
# Redis数据库索引(默认为0)
spring.redis.database=0
# Redis服务器地址
spring.redis.host=120.79.88.17
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码(默认为空)
spring.redis.password=123456
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0



JedisConfig



@Configuration
public class JedisConfig extends CachingConfigurerSupport {
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.max-idle}")
private Integer maxIdle;
@Value("${spring.redis.min-idle}")
private Integer minIdle;
@Bean
public JedisPool redisPoolFactory(){
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(maxIdle);
jedisPoolConfig.setMinIdle(minIdle);
jedisPoolConfig.setMaxWaitMillis(3000L);
int timeOut = 3;
return new JedisPool(jedisPoolConfig, host, port, timeOut, password);
}
}



基础使用



@RunWith(SpringRunner.class)
@SpringBootTest(classes = KerwinBootsApplication.class)
public class ApplicationTests {
@Resource
JedisPool jedisPool;
@Test
public void testJedis () {
Jedis jedis = jedisPool.getResource();
jedis.set("year", String.valueOf(24));
}
}



SpringBoot redis staeter RedisTemplate



<!-- redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- redis 2.X 更换为commons-pool2 连接池 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>



############# redis Config #############
# Redis数据库索引(默认为0)
spring.redis.database=0
# Redis服务器地址
spring.redis.host=120.79.88.17
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码(默认为空)
spring.redis.password=123456
# 连接池最大连接数(使用负值表示没有限制)
spring.redis.jedis.pool.max-active=200
# 连接池最大阻塞等待时间(使用负值表示没有限制)
spring.redis.jedis.pool.max-wait=1000ms
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间(毫秒)
spring.redis.timeout=1000ms



// Cache注解配置类
@Configuration
public class RedisCacheConfig {
@Bean
public KeyGenerator simpleKeyGenerator() {
return (o, method, objects) -> {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(o.getClass().getSimpleName());
stringBuilder.append(".");
stringBuilder.append(method.getName());
stringBuilder.append("[");
for (Object obj : objects) {
stringBuilder.append(obj.toString());
}
stringBuilder.append("]");
return stringBuilder.toString();
};
}
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
return new RedisCacheManager(
RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
// 默认策略,未配置的 key 会使用这个
this.getRedisCacheConfigurationWithTtl(15),
// 指定 key 策略
this.getRedisCacheConfigurationMap()
);
}
private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>(16);
redisCacheConfigurationMap.put("redisTest", this.getRedisCacheConfigurationWithTtl(15));
return redisCacheConfigurationMap;
}
private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
RedisSerializationContext
.SerializationPair
.fromSerializer(jackson2JsonRedisSerializer)
).entryTtl(Duration.ofSeconds(seconds));
return redisCacheConfiguration;
}
}



// RedisAutoConfiguration
@Configuration
@EnableCaching
public class RedisConfig {
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(factory);
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}



// 基础使用
@Resource
RedisTemplate<String,Object> redisTemplate;
redisTemplate.opsForList().rightPush("user:1:order", dataList.get(3).get("key").toString());
// 注解使用
@Cacheable(value = "redisTest")
public TestBean testBeanAnnotation () {}



Redis使用场景



| 类型 | 适用场景 |

| ------ | ------------------------------------------- |

| String | 缓存,限流,计数器,分布式锁,分布式session |

| Hash | 存储用户信息,用户主页访问量,组合查询 |

| List | 微博关注人时间轴列表,简单队列 |

| Set | 赞,踩,标签,好友关系 |

| Zset | 排行榜 |



或者简单消息队列,发布订阅实施消息系统等等



String - 缓存



// 1.Cacheable 注解
// controller 调用 service 时自动判断有没有缓存,如果有就走redis缓存直接返回,如果没有则数据库然后自动放入redis中
// 可以设置过期时间,KEY生成规则 (KEY生成规则基于 参数的toString方法)
@Cacheable(value = "yearScore", key = "#yearScore")
@Override
public List<YearScore> findBy (YearScore yearScore) {}
// 2.手动用缓存
if (redis.hasKey(???) {
return ....
}
redis.set(find from DB)...



String - 限流 | 计数器



// 注:这只是一个最简单的Demo 效率低,耗时旧,但核心就是这个意思
// 计数器也是利用单线程incr...等等
@RequestMapping("/redisLimit")
public String testRedisLimit(String uuid) {
if (jedis.get(uuid) != null) {
Long incr = jedis.incr(uuid);
if (incr > MAX_LIMITTIME) {
return "Failure Request";
} else {
return "Success Request";
}
}
// 设置Key 起始请求为1,10秒过期 -> 实际写法肯定封装过,这里就是随便一写
jedis.set(uuid, "1");
jedis.expire(uuid, 10);
return "Success Request";
}



String - 分布式锁 (重点)



/***
* 核心思路:
* 分布式服务调用时setnx,返回1证明拿到,用完了删除,返回0就证明被锁,等...
* SET KEY value [EX seconds] [PX milliseconds] [NX|XX]
* EX second:设置键的过期时间为second秒
* PX millisecond:设置键的过期时间为millisecond毫秒
* NX:只在键不存在时,才对键进行设置操作
* XX:只在键已经存在时,才对键进行设置操作
*
* 1.设置锁
* A. 分布式业务统一Key
* B. 设置Key过期时间
* C. 设置随机value,利用ThreadLocal 线程私有存储随机value
*
* 2.业务处理
* ...
*
* 3.解锁
* A. 无论如何必须解锁 - finally (超时时间和finally 双保证)
* B. 要对比是否是本线程上的锁,所以要对比线程私有value和存储的value是否一致(避免把别人加锁的东西删除了)
*/
@RequestMapping("/redisLock")
public String testRedisLock () {
try {
for(;;){
RedisContextHolder.clear();
String uuid = UUID.randomUUID().toString();
String set = jedis.set(KEY, uuid, "NX", "EX", 1000);
RedisContextHolder.setValue(uuid);
if (!"OK".equals(set)) {
// 进入循环-可以短时间休眠
} else {
// 获取锁成功 Do Somethings....
break;
}
}
} finally {
// 解锁 -> 保证获取数据,判断一致以及删除数据三个操作是原子的, 因此如下写法是不符合的
/*if (RedisContextHolder.getValue() != null && jedis.get(KEY) != null && RedisContextHolder.getValue().equals(jedis.get(KEY))) {
jedis.del(KEY);
}*/
// 正确姿势 -> 使用Lua脚本,保证原子性
String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
Object eval = jedis.eval(luaScript, Collections.singletonList(KEY), Collections.singletonList(RedisContextHolder.getValue()));
}
return "锁创建成功-业务处理成功";
}



String - 分布式Session(重点)



// 1.首先明白为什么需要分布式session -> nginx负载均衡 分发到不同的Tomcat,即使利用IP分发,可以利用request获取session,但是其中一个挂了,怎么办?? 所以需要分布式session

注意理解其中的区别 A服务-用户校验服务 B服务-业务层

情况A:
A,B 服务单机部署:
cookie:登录成功后,存储信息到cookie,A服务自身通过request设置session,获取session,B服务通过唯一key或者userid 查询数据库获取用户信息

cookie+redis:登录成功后,存储信息到cookie,A服务自身通过request设置session,获取session,B服务通过唯一key或者userid 查询redis获取用户信息


情况B:
A服务多节点部署,B服务多节点部署
B服务获取用户信息的方式其实是不重要的,必然要查,要么从数据库,要么从cookie

A服务:登录成功后,存储唯一key到cookie, 与此同时,A服务需要把session(KEY-UserInfo)同步到redis中,不能存在单纯的request(否则nginx分发到另一个服务器就完犊子了)

官方实现:
spring-session-data-redis
有一个内置拦截器,拦截request,session通过redis交互,普通使用代码依然是request.getSession.... 但是实际上这个session的值已经被该组件拦截,通过redis进行同步了



List 简单队列-栈



// 说白了利用redis - list数据结构 支持从左从右push,从左从右pop
@Component
public class RedisStack {
@Resource
Jedis jedis;
private final static String KEY = "Stack";
/** push **/
public void push (String value) {
jedis.lpush(KEY, value);
}
/** pop **/
public String pop () {
return jedis.lpop(KEY);
}
}



@Component
public class RedisQueue {
@Resource
JedisPool jedisPool;
private final static String KEY = "Queue";
/** push **/
public void push (String value) {
Jedis jedis = jedisPool.getResource();
jedis.lpush(KEY, value);
}
/** pop **/
public String pop () {
Jedis jedis = jedisPool.getResource();
return jedis.rpop(KEY);
}
}



List 社交类APP - 好友列表



根据时间显示好友,多个好友列表,求交集,并集 显示共同好友等等...
疑问:难道大厂真的用redis存这些数据吗???多大的量啊... 我个人认为实际是数据库存用户id,然后用算法去处理,更省空间



Set 抽奖 | 好友关系(合,并,交集)



// 插入key 及用户id
sadd cat:1 001 002 003 004 005 006

// 返回抽奖参与人数
scard cat:1

// 随机抽取一个
srandmember cat:1

// 随机抽取一人,并移除
spop cat:1



Zset 排行榜



根据分数实现有序列表
微博热搜:每点击一次 分数+1 即可

--- 不用数据库目的是因为避免order by 进行全表扫描



常见面试题



Q1:为什么Redis能这么快



1.Redis完全基于内存,绝大部分请求是纯粹的内存操作,执行效率高。
2.Redis使用单进程单线程模型的(K,V)数据库,将数据存储在内存中,存取均不会受到硬盘IO的限制,因此其执行速度极快,另外单线程也能处理高并发请求,还可以避免频繁上下文切换和锁的竞争,同时由于单线程操作,也可以避免各种锁的使用,进一步提高效率
3.数据结构简单,对数据操作也简单,Redis不使用表,不会强制用户对各个关系进行关联,不会有复杂的关系限制,其存储结构就是键值对,类似于HashMap,HashMap最大的优点就是存取的时间复杂度为O(1)
5.C语言编写,效率更高
6.Redis使用多路I/O复用模型,为非阻塞IO
7.有专门设计的RESP协议



针对第四点进行说明 ->

>

常见的IO模型有四种:

>

- 同步阻塞IO(Blocking IO):即传统的IO模型。

>

- 同步非阻塞IO(Non-blocking IO):默认创建的socket都是阻塞的,非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java的NIO(New IO)库。

>

- IO多路复用(IO Multiplexing):即经典的Reactor设计模式,有时也称为异步阻塞IO,Java中的Selector和Linux中的epoll都是这种模型。

>

- 异步IO(Asynchronous IO):即经典的Proactor设计模式,也称为异步非阻塞IO

>



>

同步异步,阻塞非阻塞的概念:

>



>



>

假设Redis采用同步阻塞IO:

>

Redis主程序(服务端 单线程)-> 多个客户端连接(真实情况是如开发人员连接redis,程序 redispool连接redis),这每一个都对应着一个客户端,假设为100个客户端,其中一个进行交互时候,如果采用同步阻塞式,那么剩下的99个都需要原地等待,这势必是不科学的。

>



>

IO多路复用

>

Redis 采用 I/O 多路复用模型

>

I/O 多路复用模型中,最重要的函数调用就是 select,该方法的能够同时监控多个文件描述符的可读可写情况,当其中的某些文件描述符可读或者可写时,select 方法就会返回可读以及可写的文件描述符个数

>

``注:redis默认使用的是更加优化的算法:epoll``

>

| | select | poll | epoll |

| ---------- | ---------------------------------------- | ---------------------------------------- | ------------------------------------------------------------ |

| 操作方式 | 遍历 | 遍历 | 回调 |

| 底层实现 | 数组 | 链表 | 哈希表 |

| IO效率 | 每次调用都进行线性遍历,时间复杂度为O(n) | 每次调用都进行线性遍历,时间复杂度为O(n) | 事件通知方式,每当fd就绪,系统注册的回调函数就会被调用,将就绪fd放到readyList里面,时间复杂度O(1) |

| 最大连接数 | 1024(x86)或2048(x64) | 无上限 | 无上限 |

所以我们可以说Redis是这样的:服务端单线程毫无疑问,多客户端连接时候,如果客户端没有发起任何动作,则服务端会把其视为不活跃的IO流,将其挂起,当有真正的动作时,会通过回调的方式执行相应的事件

>



Q2:从海量Key里查询出某一个固定前缀的Key



A. 笨办法:KEYS [pattern] 注意key很多的话,这样做肯定会出问题,造成redis崩溃

>

B. SCAN cursor [MATCH pattern] [COUNT count] 游标方式查找



Q3:如何通过Redis实现分布式锁



见上文



Q4:如何实现异步队列



上文说到利用 redis-list 实现队列
假设场景:A服务生产数据 - B服务消费数据,即可利用此种模型构造-生产消费者模型

1. 使用Redis中的List作为队列
2.使用BLPOP key [key...] timeout -> LPOP key [key ...] timeout:阻塞直到队列有消息或者超时
(方案二:解决方案一中,拿数据的时,生产者尚未生产的情况)

3.pub/sub:主题订阅者模式
基于reds的终极方案,上文有介绍,基于发布/订阅模式
缺点:消息的发布是无状态的,无法保证可达。对于发布者来说,消息是“即发即失”的,此时如果某个消费者在生产者发布消息时下线,重新上线之后,是无法接收该消息的,要解决该问题需要使用专业的消息队列



Q5:Redis支持的数据类型?



见上文



Q6:什么是Redis持久化?Redis有哪几种持久化方式?优缺点是什么?



持久化就是把内存的数据写到磁盘中去,防止服务宕机了内存数据丢失。

>

Redis 提供了两种持久化方式:RDB(默认) 和AOF

>

RDB:

>

rdb是Redis DataBase缩写

>

功能核心函数rdbSave(生成RDB文件)和rdbLoad(从文件加载内存)两个函数

>



>



>

RDB: 把当前进程数据生成快照文件保存到硬盘的过程。分为手动触发和自动触发

>

手动触发 -> save (不推荐,阻塞严重) bgsave -> (save的优化版,微秒级阻塞)

>

``shutdowm 关闭服务时,如果没有配置AOF,则会使用bgsave持久化数据``

>

bgsave - 工作原理

>

会从当前父进程fork一个子进程,然后生成rdb文件

>

缺点:频率低,无法做到实时持久化

>



>

AOF:

>

Aof是Append-only file缩写,AOF文件存储的也是RESP协议

>



>

每当执行服务器(定时)任务或者函数时flushAppendOnlyFile 函数都会被调用, 这个函数执行以下两个工作

>

aof写入保存:

>

WRITE:根据条件,将 aof_buf 中的缓存写入到 AOF 文件

>

SAVE:根据条件,调用 fsync 或 fdatasync 函数,将 AOF 文件保存到磁盘中。

>

存储结构:

>

内容是redis通讯协议(RESP )格式的命令文本存储

>

原理:

>

相当于存储了redis的执行命令(类似mysql的sql语句日志),数据的完整性和一致性更高

>

比较

>

1、aof文件比rdb更新频率高

>

2、aof比rdb更安全

>

3、rdb性能更好

>



>

PS:正确停止redis服务 应该基于连接命令 加再上 shutdown -> 否则数据持久化会出现问题



Q7:redis通讯协议(RESP)



Redis 即 REmote Dictionary Server (远程字典服务);

>

而Redis的协议规范是 Redis Serialization Protocol (Redis序列化协议)

>

RESP 是redis客户端和服务端之前使用的一种通讯协议;

>

RESP 的特点:实现简单、快速解析、可读性好

>



>

协议如下:

>

客户端以规定格式的形式发送命令给服务器

>

```

set key value 协议翻译如下:



* 3 -> 表示以下有几组命令



$ 3 -> 表示命令长度是3

SET



$6 -> 表示长度是6

keykey



$5 -> 表示长度是5

value



完整即:

* 3

$ 3

SET

$6

keykey

$5

value

```

>



>

>



>

服务器在执行最后一条命令后,返回结果,返回格式如下:

>

For Simple Strings the first byte of the reply is "+" 回复

>

For Errors the first byte of the reply is "-" 错误

>

For Integers the first byte of the reply is ":" 整数

>

For Bulk Strings the first byte of the reply is "$" 字符串

>

For Arrays the first byte of the reply is "*" 数组



// 伪造6379 redis-服务端,监听 jedis发送的协议内容
public class SocketApp {
/***
* 监听 6379 传输的数据
* JVM端口需要进行设置
*/
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(6379);
Socket redis = serverSocket.accept();
byte[] result = new byte[2048];
redis.getInputStream().read(result);
System.out.println(new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}
}
// jedis连接-发送命令
public class App {
public static void main(String[] args){
Jedis jedis = new Jedis("127.0.0.1");
jedis.set("key", "This is value.");
jedis.close();
}
}
// 监听命令内容如下:
*3
$3
SET
$3
key
$14



Q8:redis架构有哪些



单节点



主从复制



Master-slave 主从赋值,此种结构可以考虑关闭master的持久化,只让从数据库进行持久化,另外可以通过读写分离,缓解主服务器压力



哨兵



Redis sentinel 是一个分布式系统中监控 redis 主从服务器,并在主服务器下线时自动进行故障转移。其中三个特性:

监控(Monitoring): Sentinel 会不断地检查你的主服务器和从服务器是否运作正常。

提醒(Notification): 当被监控的某个 Redis 服务器出现问题时, Sentinel 可以通过 API 向管理员或者其他应用程序发送通知。

自动故障迁移(Automatic failover): 当一个主服务器不能正常工作时, Sentinel 会开始一次自动故障迁移操作。

特点:
1、保证高可用
2、监控各个节点
3、自动故障迁移

缺点:主从模式,切换需要时间丢数据
没有解决 master 写的压力



集群





>

从redis 3.0之后版本支持redis-cluster集群,Redis-Cluster采用无中心结构,每个节点保存数据和整个集群状态,每个节点都和其他所有节点连接。

>

特点:

>

1、无中心架构(不存在哪个节点影响性能瓶颈),少了 proxy 层。

>

2、数据按照 slot 存储分布在多个节点,节点间数据共享,可动态调整数据分布。

>

3、可扩展性,可线性扩展到 1000 个节点,节点可动态添加或删除。

>

4、高可用性,部分节点不可用时,集群仍可用。通过增加 Slave 做备份数据副本

>

5、实现故障自动 failover,节点之间通过 gossip 协议交换状态信息,用投票机制完成 Slave到 Master 的角色提升。

>

缺点:

>

1、资源隔离性较差,容易出现相互影响的情况。

>

2、数据通过异步复制,不保证数据的强一致性



Q9:Redis集群-如何从海量数据里快速找到所需?



  • #### 分片



按照某种规则去划分数据,分散存储在多个节点上。通过将数据分到多个Redis服务器上,来减轻单个Redis服务