Redis学习

最新推荐文章于 2021-12-18 23:27:40 发布
最新推荐文章于 2021-12-18 23:27:40 发布
阅读量282 收藏
点赞数
文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44954686/article/details/115581841
版权

Redis学习

文章目录

nosql概述

为什么要用nosql？

大数据时代，一般的数据库无法对大数据进行分析处理！

数据量爆发增长，一般数据库无法处理，nosql可以很好的处理这种情况

一般网站的瓶颈

  1. 数据量
  2. 数据的索引
  3. 数据的访问量
Memcache+mysql+垂直拆分（读写分离）

缓存机制：网站80%得到情况都是在读，每次都要去查询数据得到话就会十分的麻烦，所以我们希望减轻数据的压力，可以使用缓存来保证效率

缓存的发展过程：优化数据结构和索引---->文件缓存（IO）---->Memcache（当时最热门的技术）

分库分表+水平拆分+mysql集群

MySQL引擎：

  • MyISAM引擎：表锁，同步数据是会将该数据所在的表锁住，十分影响效率，会造成严重的锁问题
  • Innodb：行锁，

什么是nosql

NoSQL=Not Only SQL（不仅仅是sql），泛指非关系型数据库，

非关系型数据库诞生的缘由：随着web2.0互联网的诞生，传统的关系型数据库很难处理web2.0时代，尤其是超大规模的高并发的社区。

很多的数据类型不一定需要一个固定的格式，

不需要多余的操作就可以横向的拓展。

nosql特点

  1. 方便拓展：数据之间没有关系，很好拓展
  2. 大数据量，高性能（redis一秒可以写8万次，读11万次，NoSQL的缓存记录级，是一种细粒度的缓存，性能会比较高）
  3. 数据类型是多样型的，不需要事先设计数据库，随取随用！
  4. 传统的RDBMS和NoSQL区别
  • 传统的RDBMS
    • 结构化组织
    • SQL
    • 数据和关系都存储在单独的表中
    • 数据操作，数据定义语言
    • 严格的一致性
  • NoSQL
    • 不仅仅是数据
    • 没有固定的查询语言
    • 键值对存储，列存储，文档存储，图形数据库
    • 最终一致性：可以存在误差性，只要最终结果一致就行
    • CAP定理和BASE定理
    • 高性能，高可用，高可拓展\

3V+3高（了解）：

  • 大数据时代的3V：主要描述问题的
    • 海量（volume）
    • 多样（variety）
    • 实时（velocity）
  • 大数据时代大的3高：主要是对程序的要求
    • 高并发
    • 高可拓
    • 高性能
阿里第五代网站架构使命

  1. 敏捷

    • 业务快速增长，每天都养上线大量的小需求
    • 应用系统日渐膨胀，耦合恶化，架构越来越复杂，会带来更高的开发成本

  2. 开放

    • 提升网站的开放性，吸引第三方开发者加入

  3. 体验

    • 网站的并发压力快速增长，用户对体验提出了更高的要求

NoSQL的四大分类

  • kv键值对
  • 文档型数据库（bson格式）
    • mongoDB：基于一个分布式文件存储的数据库，c++编写，主要用来处理大量的文档
    • mongoDB是一个介于关系型数据库和非关系型数据库中的中间产品，是非关系型数据库中最像关系型数据库的
  • 列存储数据库
    • HBase
    • 分布式文件系统
  • 图关系数据库：不是用来存储图形的，是存储关系的

Redis入门

概述

Redis是什么

Redis（Remote Dictionary Server ）,即远程字典服务。是一种开源使用 的ANSI，由c语言编写，支持网络，可基于内存亦可持久化的日志型，key-value数据库，并提供多种语言的API。也被人称之为结构型数据库

Redis能干什么

  1. 内存存储，持久化。
  2. 效率高，可用于告诉缓存
  3. 发布订阅系统
  4. 地图信息分析
  5. 计数器，计时器

特性

  1. 多样的数据类型
  2. 持久化
  3. 集群
  4. 事务

基础知识

redis默认有16个数据库，默认为0号数据库

# select index  切换数据库
# keys * 查看当前数据库中所有的key
# flushdb 清空当前数据库
# flushall 清空所有数据库

redis是单线程的，redis是基于内存操作的，CPU不是redis的性能瓶颈，而是机器的内存和网络带宽，既然 可以使用单线程，就使用单线程。

redis为什么单线程还那么快？

CPU速度>内存速度>硬盘速度

redis是将所有的数据放入内存中，所以使用单线程去操作，效率就是最高的，多线程cpu上下文一定会切换。对于内存系统来说，没有上下文切换效率就是最高的，多次读写都在一个cpu上，效率较高。

​

五大数据类型

redis是一个开源的，内存中的数据结构存储系统，它可以作为数据库，缓存和消息中间件MQ，它支持多种类型大的数据结构。内置了复制，LUA脚本，LRU驱动事件，事务和不同级别的磁盘持久化，并通过redis哨兵和自动分区提供高可用性

Redis-Key
# move key indexDB 将指定的key转移到指定的数据库中
# set key value    添加kv键值对
# get key 		   根据key获取value
# EXPIRE key second  设kv键值对的有效时间 单位为秒
# ttl key  		   查看key的有效时间
# type key		   查看当前key的类型
# EXISTS key       当前key是否存在
String（字符串）xx
# APPEND Key xx 在key所对应的value后追加字符串xx
# STRLEN key 获取key所对应的value的字符串长度
# incr key   值自增1
# decr key   值自减1
# INCRBY key num 值根据num自增
# DECRBY key num 值根据num自减
# GETRANGE key start end 获取从star到end的字符串
# SETRANGE key start replace  替换指定位置开始的字符串
# setex key second value   	  设置键值对的有效时间second
# setnx key value		      如果该key不存在，则创建该key，如果key存在，则创建失败（一般在分布式锁中使用）
# mset k1 v1 k2 v2 k3 v3 批量添加kv键值对
# mget k1 k2 k3 批量获取值
# msetnx k1 v1 k2 v2 如果key不存在，则创建键值对，同时成功，同时失败。如果key存在则创建失败

##############
# 对象：
# mset user:1:name bob user:1:age 18   ==>user:{id}:{filed} 

#getset key value  先get在set
List列表

所有的list命令都是以l开头

# LPUSH list value 将值存入列表中
# LRANGE list start end 从list列表中获取指定位置的值，先进后取
# RPUSH		将值插入列表尾部

# LPOP		左移除，移除第一个元素
# RPOP		右移除，移除最后一个元素

# lindex list index 通过下标获取值
# lrem list count value 	移除 lit集合中之地指定个数的value，精确匹配 
# ltrim list start end 		从指定位置截取列表

# rpoplpush list1 list2		右移除list1的元素左添加至list2
# lset list index value		如果列表存在，则更新该列表下标的值为value，如果列表不存在，则会报错
# LINSERT list before|after value value1   在该列表中在value前或后插入数据value1
Set（集合）

set中的值是不能重复的，无序不重复集合

# sadd set value		向set中添加元素
# SMEMBERS set			查看set中的元素
# SISMEMBERS set value  查询set中是否含有value值
# srem set value		移除set中的value元素
# SRANDMEMBER set [num]			随机从set中抽取num个元素,num可以不写，默认为一个
# spop set 				随机弹出一个元素
# smove set1 set2 value		将set1中的value转移到set2中
# SDIFF set1 set2		查询set1和set2的差集
# SINTER set1 set2		查询set1和set2的交集
# SUNION set1 set2		查询set1和set2的并集
Hash（哈希）

map集合

# hset map key value		将kv键值对存入map中
# hmset map k1 v1 k2 v2		将多个kv键值对存入
# hget map key				根据key从map中获取value
# hmget map k1 k2			根据多个key从map中获取多个value
# hdel map key				根据key从map中删除value
# hgetall map				获取map中所有的数据
# hlen map					获取map中的字段数量
# HEXISTS map field			判断map中是否存在field
# hkeys map					获取map中所有的key
# hvals map					获取map中所有的value
# HINCRBY map field num		根据num对field的value进行自增num
# HDECRBY map field num		根据num对field的value进行自减num
Zset（有序集合）

在set的基础上加了一个score

# zadd set score member		根据score对set进行存储排序到set中
# ZRANGEBYSCORE set min max 根据score的大小对set中的元素排序
# zcard set					获取有序集合中的个数
# zcount set start end 		获取指定区内的集合数量

三种特殊类型

geospatial（地理位置）
# geoadd key 经度 维度 名称		添加地理位置，两级无法直接添加
# geopos key 名称				   获取指定城市的经纬度
# geodist key 名称1 名称2 		 获取两地之间的距离
# georadius key 经度 维度 半径 	以此经纬度为中心寻找半径内的所有点
# georadius key 经度 维度 半径 withdist(显示到中心的距离) withcoord(显示周围信息) count(限制显示的数量)
# georadiusbymember key member radius 找出位于指定元素周围的其他元素
# geohash key member			返回一个经纬度的字符串
Hyperloglog

基数计算的算法，允许容错

优点：占用的内存是固定的，2^64不同的元素的技术，只需要使用12KB内存

使用场景：网页的UV（一个人访问网页多次，但是还是算作一次访问）

# pfadd key element			创建一组元素
# pfcount key				统计key中的元素数量
# pfmerge newkey key1 key2  合并key1，key2到newkey 并集
Bitmap

位存储，操作二进制位来进行记录，只有0和1两个状态

使用场景：统计用户信息，活跃，不活跃，登录，未登录。只有两个状态

# setbit key offset value		添加
# getbit key offset				获取
# bitcount key					统计

Redis基本的事务操作

redis单条命令是保证原子性的，但是事务不保证原子性，没有隔离级别的概念

Redis事务的本质：一组命令的集合，一个事务中所有命令都会呗序列化，在事务执行过程中，会按照顺序执行！

一次性，顺序性，排他性，执行一些命令。

过程：

  • 开启事务（multi）
  • 命令入队
  • 执行事务（exec）
  • 放弃事务（discard）

编译型异常：事务中所有的命令都不会被执行

运行时异常：事务中存在语法异常，那么执行命令得到时候，其他的命令是可以正常执行的，错误命令抛出异常

监控（watch）：可以当作乐观锁操作

取消监控（unwatch）

悲观锁：

  • 认为无论做什么都会出现问题，无论做什么都会加锁

乐观锁;

  • 认为什么时候都不会出现问题，所以不会上锁，更新数据的时候去判断下，是否有人修改过这个数据

Jedis

什么时jedis：

是redis官网推荐的Java连接开发工具

记一次Jedis踩坑！！！！

使用jedis时 出现JedisConnectionException: Failed connecting to host localhost:6379异常

  • 如果你使用的是虚拟机，先检查虚拟机的防火墙是否关闭，如果没有关闭，将防火墙关闭（这个坑我愣是看了半个小时）
    • 查看防火墙状态命令：firewall-cmd --state
    • 关闭防火墙命令：systemctl stop firewalld.service
    • 禁止防火墙开机启动：systemctl disable firewalld.service
    • 再就是将localhost改为你的内网ip（可以通过ifconfig命令进行查询的你的内网ip）
  • 再将redis.conf配置文件中的bind 127.0.0.1注释掉
  • 关闭保护模式 protected-mode no

springboot整合Redis

springdata操作数据：spring-data，jpa jdbc mongdb redis

springboot2.x之后，原来使用的jedis替换成lettuce

jedis：采用的是直连，多个线程操作的话是不安全的，如果想要避免不安全。就需要使用jedis线程池

lettuce：采用netty，实例可以再多个线程中进行共享，不存在不安全的情况，可以减少线程数量

在使用redisTemplate传输对象时，对象需要被序列化

源码：
    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )//当没有自定义redisTemplate时，使用该组件
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        //默认的redisTemplate没有进行过多的设置，redis对象都是需要序列化
        //两个泛型都是object，后面需要强制转换
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	//由于string是redis中最常使用的类型，所以单独提取出来一个bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
基本的redisTemplate操作：
        //操作不同的数据类型
        redisTemplate.opsForValue();
        redisTemplate.opsForList();
        redisTemplate.opsForSet();
        redisTemplate.opsForHash();
        //...
        //常用的方法，可以直接通过redisTemplate操作，比如说事务，和基本的CRUD
        redisTemplate.multi();
        redisTemplate.move();
        redisTemplate.delete();
        //...

		//对数据库的一些基本操作
		RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushDb();
自定义redisTemplate
package com.fish.redis.config;


import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean("redisTemplate")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //使用Jackson2JsonRedisSerializer对任意的object对象进行序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //objectMapper是jackson将java对象和json格式相互转换
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        //可以对objectMapper进行配置，然后装配到jackson2JsonRedisSerializer中
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //设置key采用string的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        //设置value采用jackson的序列化方式
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        //设置hash的序列化方式为jackson2JsonRedisSerializer
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

}

尽量使用工具类将redisTemplate封装到工具类中，使用时不必重复调用

Redis.conf配置文件

INCLUDES：可以将其他的配置文件添加到此配置文件中

NETWORK:网络配置

# bind 127.0.0.1		绑定ip地址
# protected-mode yes	保护模式
# port					端口

GENERAL:通用

# daemonize yes		以守护进程方式运行，默认为no，我们需要改为yes

# pidfile /var/run/redis_6379.pid 如果我们是以后台方式运行，我们就需要一个pid文件


日志：
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)

# loglevel notice 日志的级别，以上述级别为准
# logfile ""		  日志文件的位置

# database 16		默认的数据库数量
# always-show-logo yes		是否总是显示logo

SNAPSHOTTING:快照

持久化，在规定的时间内，执行了多少次操作，则会持久化到文件 .rdb , .aof

因为redis是内存数据库，而内存是断电即失的，所以必须进行持久化操作

# 在900s内，如果至少有1个key进行了修改，我们即要进行持久化操作
save 900 1
# 在300s内，如果至少有10个key进行了修改，我们即要进行持久化操作
save 300 10
# 在60s内，如果至少有10000个key进行了修改，我们即要进行持久化操作
save 60 10000

stop-writes-on-bgsave-error yes		#持久化出错，是否还继续工作
rdbcompression yes					#是否压缩rdb文件，需要消耗一些cpu资源
rdbchecksum yes						#保存rdb文件时，进行错误的检查校验

dir ./								#rdb文件的保存目录

REPLICATION:复制，主从复制

SECURITY :安全

requirepass			#设置密码，默认没有密码		auth命令输入密码，进行登录

CLIENTS:限制客户端

# maxclients 10000		设置最大的客户端数量
# maxmemory <bytes>		redis配置的最大内存容量
# maxmemory-policy noeviction		内存到达上限之后的处理策略
	-volatile-lru：只对设置了过期时间的key进行LRU（默认值） 
	-allkeys-lru ： 删除lru算法的key   
	-volatile-random：随机删除即将过期key   
	-allkeys-random：随机删除   
	-volatile-ttl ： 删除即将过期的   
	-noeviction ： 永不过期，返回错误

REPLICATION：主从复制

################################# REPLICATION #################################

# Master-Replica replication. Use replicaof to make a Redis instance a copy of
# another Redis server. A few things to understand ASAP about Redis replication.
#
#   +------------------+      +---------------+
#   |      Master      | ---> |    Replica    |
#   | (receive writes) |      |  (exact copy) |
#   +------------------+      +---------------+
#
# 1) Redis replication is asynchronous, but you can configure a master to
#    stop accepting writes if it appears to be not connected with at least
#    a given number of replicas.
# 2) Redis replicas are able to perform a partial resynchronization with the
#    master if the replication link is lost for a relatively small amount of
#    time. You may want to configure the replication backlog size (see the next
#    sections of this file) with a sensible value depending on your needs.
# 3) Replication is automatic and does not need user intervention. After a
#    network partition replicas automatically try to reconnect to masters
#    and resynchronize with them.
#
replicaof <masterip> <masterport>		#这里配置所属主机的的ip和端口

# If the master is password protected (using the "requirepass" configuration
# directive below) it is possible to tell the replica to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the replica request.
#
masterauth <master-password>			#若主机需要密码，这里填写主机的密码

APPEND ONLY MODE :aof配置

appendonly no		#默认情况下时是不开启的，默认是以rdb方式进行持久化。在大部分情况下，rdb是完全够用的
appendfilename "appendonly.aof"		#持久化文件的名字

# appendfsync always		#每次修改都会sync，消耗性能
appendfsync everysec		#每秒执行一次sync。可能会丢失一秒的数据
# appendfsync no			#不执行sync，操作系统自己同步数据。速度最快

Redis持久化

redis是内存数据库，如果不将内存中的数据库状态保存到磁盘中，那么一旦服务器进程退出，服务器中的状态也随之消失。所以redis提供了持久化功能。

RDB（Redis DataBase）

在指定的时间间隔内将内存中的数据集快照写入磁盘，用行话来讲就是snapshot快照。它恢复时将快照文件直接读到内存中

redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中。待持久化过程结束后，再将这个临时文件替换上次持久化好的文件。整个过程中。主进程是不进行任何的IO操作的。这就确保了极高的性能。如果需要进行大规模数据恢复，且对于数据恢复的完整性不是非常敏感，那么RDB方式要比AOF方式更加的高效。RDB的缺点时最后一次持久化的数据可能会丢失。我们默认的就是RDB,一般情况下不需要修改这个配置。

rbd保存的文件就是dump.rdb

触发机制

  • save的规则满足的情况下，会触发rdb规则
  • 执行flushall也会触发rdb规则
  • 退出redis，也会产生rdb文件

备份就会自动生成一个dump.rdb

恢复rdb文件

只需要将rdb文件放到redis的启动目录即可，redis启动时会自动检查dump.rdb恢复其中的数据

优点：

  • 适合大规模的数据恢复！
  • 对数据的完整性不高

缺点：

  • 需要一定的时间间隔，如果redis意外宕机，那么最后一次修改的数据就没有了
  • fork进程会占用一定的内存空间
AOF(append only file)

以日志的形式记录每个写操作，将Redis执行过的所有指令记录下来（读操作不进行记录），只许追加文件但不改写文件，redis启动之初会去读取该文件重新构建数据。换而言之，redis重启时就根据日志文件的内容将写指令从前到后执行一次已完成数据的恢复工作

aof保存的是append.aof文件

默认是不开启aof的，需要手动打开。

如果aof文件有错误时，redis-cli是不能启动的，需要修复这个文件，redis给我们提供了一个文件redis-check-aof

修复命令:

redis-check-aof --fix appendonly.aof

优点：

  • 每一次修改都同步，文件的完整性会更好，默认开启每秒同步一次

缺点：

  • 相对于数据文件来说，，aof远远大于rdb，修复速度也比rdb慢！
  • aof的运行效率也比rdb慢，所以我们的默认配置是rdb

重写规则：如果aof文件超过64m，就会fork一个新的进程来对我们的文件继续重写

# redis.conf ===APPEND ONLY MODE=====
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

拓展：

  • RDB持久化方式能够在指定的时间间隔内对你的数据进行快照存储
  • AOF持久化方式记录每次对服务器写的操作，当服务器重启的时候会执行这些命令来恢复原始的数据，AOF命令以Redis协议追加保存每次写的操作到文件末尾，redis还能对aof文件进行后台重写，使得aof文件的体积不至于过大。
  • 只做缓存，如果你只希望你的数据在服务器运行的时候存在，也可以不使用任何持久化
  • 同时开启两种持久化方式
    • 在这中情况下，当redis重启时会优先加载aof文件来恢复原始的数据，因为在通常情况下aof文件保存的数据集要比RDB文件保存的数据集要完整。
    • RDB的数据不实时，同时使用两者时服务器重启也只会找aof文件，那要不要只使用aof呢？这里建议是不要。因为rdb更加适合用于备份数据库（AOF在不断变化，不好备份），快速重启，而且不会AOF潜在的bug，留着作为万一的手段
  • 性能建议
    • 应为rdb文件只用于后备用途，建议在save上持久化rdb文件，而且只要15分钟内备份一次就够了，只保留save 900 1这条规则
    • 如果EnableAOF,好处是在最恶劣的情况下也只会丢失不超过两秒的数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持久的IO，二是AOF rewrite的最后将rewrite过程产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应当减少AOF rewrite的频率，AOF重写的基础大小默认为64M太小。可以设置到5G上。
    • 如果不EnableAOF,仅靠master-slave repllcation实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果master/save同时倒下，会丢失十几分钟的数据，启动脚本也要比较两个master/slave中的rdb文件，载入较为新的那个。

Redis发布和订阅

订阅端：

127.0.0.1:6379> SUBSCRIBE fish		#订阅一个频道
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "fish"
3) (integer) 1
# 等待推送信息
1) "message"		#消息
2) "fish"			#来自哪个频道
3) "this is a message"		#消息的具体

发布端

127.0.0.1:6379> PUBLISH fish "this is a message"		#发布者发布消息到频道
(integer) 1
127.0.0.1:6379>

原理

redis是使用c实现额，通过分析redis源码里的pubsub.c文件，了解发布和订阅机制的底层实现，籍此加深对redis的理解

redis通过PUBLISH,SUBSCRIBE和PSUBSCRIBE等命令等实现发布和订阅功能

通过SUBSCRIBE命令订阅某频道后，redis-server里维护了一个字典，这个字典就是一个个channel，而字典的值则是一个链表，链表上保存了所有订阅这个channel的客户端，SUBSCRIBE命令的关键，就是将客户端添加到给定channel的订阅链中。

通过PUBLISH命令向订阅者发送消息，redis-server会使用给定的频道作为键，在它维护的channel字典中查找订阅了这个频道的所有客户的链表，遍历这个链表，将消息发布给所有订阅者。

PUB/SUB从字面上理解就是发布（publish）和订阅（subscribe），在redis中，你可以设定对某一个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅它的客户都会收到相应的消息。这个功能最明显的用法就是用作实时消息系统，比如普通的即时聊天，群聊等功能。

Redis主从复制

概念

主从复制，是指将一台redis服务器大的数据，复制到其他的redis服务器，前者称为主节点（master/leader），后者称为从节点（slave/follwer）；数据的复制是单向的，只能从主节点到从节点。master以写为主，slave以读为主

默认情况下，每台redis服务器都是主节点，且每个主节点可以有多个从节点（或者没有），但一个从节点只能由一个主节点。

主从复制的作用
  • 数据冗余：主从复制实现了数据的热备份是，是持久化之外的一种数据冗余方式
  • 故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复；实际上是一种服务的冗余
  • 负载均衡：主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供服务（即写redis数据时应用连接主节点，读redis数据时应用连接从节点），分摊服务器负载；尤其在写少读多的场景下，通过多个节点分摊读负载，可以大大提高redis服务器的并发性。
  • 高可用基石：除了上述作用以外，主从复制还是哨兵和集群能够给实施的基础，因此说主从复制是redis高可用的基础

一般来说，要将redis运用于工程项目中，只使用一台redis是万万不能的

  • 从结构上，单个redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大
  • 从容量上，单个redis服务器内存容量有限，就算一台redis服务器内存容量为256G，也不能将所有内存用作redis存储内存，一般来说，单台redis最大使用内存不应该超过20G

电商网站上的商品，一般都是一次性上传，无数次浏览，专业来说就是写少读多

环境配置

只用配置从库，不用配置主库，redis默认为主库

127.0.0.1:6379> info replication		#查看当前库的信息
# Replication
role:master	
connected_slaves:0
master_replid:d13747ae2f9504a875e99cff797f80e8df827c20
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

复制三个配置文件，然后修改对应的信息

  • 端口（port）
  • pid
  • 日志文件名称
  • rdb文件名称

配置从机

127.0.0.1:6380> SLAVEOF 127.0.0.1 6379			#设置6380为6379的从机
OK
127.0.0.1:6380> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6379
master_link_status:up
master_last_io_seconds_ago:5
master_sync_in_progress:0
slave_repl_offset:56
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:68ff87f5bb7b0c05a6351c2871e6f0bf506fca28
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:56
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:29
repl_backlog_histlen:28

由于我们是使用命令来配置从机，所以这种主从关系只是暂时的，要想永久的配置从机，需要在配置文件中修改。

细节
  • 主机可以写，从机只能读不能写。主机中所有的信息和数据都会自动的被从机保存
  • 主机断开连接，从机依旧连接主机，但是没有写操作，如果这个时候主机回来了，从机依旧可以直接获取到主机写的信息
  • 如果从机是通过命令配置，那么从机重启后，只会有作为从机的信息，而不会有主机在从机断开时间内写的信息（应为从机在进行重启后又变回了主机，所以并不能接受到另一台主机的写信息），当再次成为主机的从机之后，就会重新拥有主机的所有信息和数据。
复制原理
  • slave启动成功连接到一个master后会发送一个sync命名
  • master接到命令后，启动后台的存储进程，同时收集所有接收到用于修改数据集命令，在后台进程执行完毕后，master将传送整个数据文件到slave，并完成一次完全同步
    • 全量复制：slave服务在接受到数据库文件数据后，将其存盘并加载到内存中
    • 增量复制：master继续将新的所有收集的修改命令一次传给slave，完成同步
  • 但是只要是重新连接到master，一次完全同步（全量复制）将被自动执行

从机转换为主机

slaveof no one		#将从机变为主机

哨兵模式

自动选择主机的模式

概述

主从切换技术的方法是：当主服务器宕机后，需要手动把一台服务器切换为主服务器，这就需要人工干预，费时费力，还会造成一段时间内服务不可用。这不是一种推荐的方式。更多时候，我们优先考虑哨兵模式。redis从2.8开始正式提供sentinel架构来解决这个问题

哨兵模式能够后台监控主机是否发生故障，如果故障了，根据投票数自动将从库转换为主库。

哨兵模式是一种特殊的模式，首先redis提供了哨兵的命令，哨兵是一个独立的进程，最为进程，他会独立运行。其原理是哨兵通过发送命令，等待redis服务器响应，从而监控运行的多个redis实例。

哨兵的作用：

  • 通过发送命令，redis服务器返回监控其运行状态，包括主服务器和从服务器
  • 当哨兵监测到master宕机，会自动将slave切换为master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让他们切换主机

然而一个哨兵进程对redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控，各个哨兵还会相互监控，这样就形成了多哨兵模式

假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover（切换主机），仅仅是哨兵1主观认为这个服务器不可用，这个现象称为主观下线，当后面的哨兵也检测到主服务器不可用，当数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover故障转移（切换主机），切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线

如果主机重启后，只能归并到新的主机下当作从机。

测试

  1. 配置哨兵配置文件sentinel.conf

    • sentinel monitor myredis 127.0.0.1 6379 1			
				#被监控的名称 host port 
				#1代表主机宕机，slave投票看让谁接替成为主机，票数最多的，就会称为主机

  2. 启动哨兵

    • redis-sentinel /usr/local/redis/etc/sentinel.conf			
				#sentinel配置文件

优点：

  • 哨兵集群，基于主从复制，所有的主从配置优点他都有
  • 主从可以切换，故障可以转换，系统的可用性就会更好
  • 哨兵模式就是主从模式的升级，手动到自动更加的健壮

缺点：

  • redis不好在线扩容，集群容量一旦到达上限，在线扩容就会十分的麻烦
  • 实现哨兵模式的配置其实是十分麻烦的。

Redis缓存穿透和雪崩

redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面，但同时，他也带来了一些问题，其中最要害的问题就是数据的一致性问题。从严格意义上来讲，这个问题是无解的。如果对数据的一致性要求性很高，那么就不能使用缓存。

另外的一些典型问题就是，缓存穿透，缓存雪崩和缓存击穿。

缓存穿透

缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候缓存都没有命中，于是都去请求持久层数据库，这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。

解决方案

布隆过滤器

布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力

缓存空对象

当存储层不命中后，即使返回的空对象也将其缓存起来，同时设置一个过期时间，之后在访问这个数据将会从缓存中获取，保护了后端数据源

但是这种方法存在两个问题

  • 如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多空值的键
  • 即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致。这对于需要保持一致性的业务会有影响

缓存击穿

这里需要注意和缓存穿透的区别，缓存击穿是指一个key非常热点，在不停的扛着大并发，大并发集中对着一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就相当于在屏障上凿开了一个洞。

当某个key在过期的瞬间，由大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询罪行数据，并回写缓存，会导致数据库瞬间压力增大。

解决方案

设置热点数据永不过期

从缓存层面上看，没有设置过期时间，所以不会出现热点key过期后产生的问题

加互斥锁

分布式锁：使用分布式锁，保证对于每个key同时只用一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此等待即可，这种方式将高并发的压力转移到了分布式锁，因此对于分布式锁的考验很大。

缓存雪崩

缓存雪崩，是指在某一个时间段，缓存集中过期失效。redis宕机

解决方案

redis高可用

就是，既然redis有可能挂掉，那么就增加redis服务器的数量，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。

限流降级

这个解决方案的思想是，在缓存失效后，通过加锁或者控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待

数据预热

有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候缓存都没有命中，于是都去请求持久层数据库，这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。

解决方案

布隆过滤器

布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力

缓存空对象

当存储层不命中后，即使返回的空对象也将其缓存起来，同时设置一个过期时间，之后在访问这个数据将会从缓存中获取，保护了后端数据源

但是这种方法存在两个问题

  • 如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多空值的键
  • 即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致。这对于需要保持一致性的业务会有影响

缓存击穿

这里需要注意和缓存穿透的区别，缓存击穿是指一个key非常热点，在不停的扛着大并发，大并发集中对着一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就相当于在屏障上凿开了一个洞。

当某个key在过期的瞬间，由大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询罪行数据，并回写缓存，会导致数据库瞬间压力增大。

解决方案

设置热点数据永不过期

从缓存层面上看，没有设置过期时间，所以不会出现热点key过期后产生的问题

加互斥锁

分布式锁：使用分布式锁，保证对于每个key同时只用一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此等待即可，这种方式将高并发的压力转移到了分布式锁，因此对于分布式锁的考验很大。

缓存雪崩

缓存雪崩，是指在某一个时间段，缓存集中过期失效。redis宕机

解决方案

redis高可用

就是，既然redis有可能挂掉，那么就增加redis服务器的数量，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。

限流降级

这个解决方案的思想是，在缓存失效后，通过加锁或者控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待

数据预热

数据预热的含义就是在正式部署前，先把可能的数据访问一边，这样部分可能大量访问的数据就会加载到缓存中，在即将发生的大并发访问前手动触发加载缓存不同的kye，设置不同的过期时间，让缓存失效的时间点尽量均匀。

至此，感谢B站狂神说的教学视频！！

gPlayer-zero
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
redis学习笔记
12-30
redis学习笔记redis 是一个开源的 key-value 数据库。它又经常被认为是一个数据结构服务器。 因为它的 value 不仅包括基本的 string 类型还有 list,set ,sorted set 和 hash 类型。当 然这些类型的元素也都是 string...
Redis学习汇总（已完结）
热门推荐
大鱼的博客
01-19 29万+
Redis学习汇总 Windows和Linux下如何安装Redis Redis（一）入门：五大数据类型的学习和理解① Redis（一）入门：五大数据类型的学习和理解② 未完待续~ 写作不易，如果您觉得写的不错，欢迎给博主点赞、收藏、评论、收藏来一波~让博主更有动力吧！ 路漫漫其修远兮，吾必将上下求索~ ...
狂神说redis学习笔记
fl8545的博客
11-05 3704
文章目录Redis历史演进nosql数据模型nosql四大分类CAPBASERedis入门Redis安装下载WindowsLinux性能测试工具基础知识补充五大基本数据类型stringListSetHashZset三种特殊数据类型geohyperloglogbitmapredis配置详解redis持久化RDBAOFredis事务操作redis实现订阅发布redis主从复制redis哨兵模式缓存穿透及解决方案缓存击穿及解决方案缓存雪崩及解决方案基础API之Jedis详解Springboot集成Redis操作r
redis学习
10000day
12-18 1343
1、redis nosql数据库、缓存中间件，消息中间件 2、键值、列表等 3、c语言单线程：瓶颈在内存速度和网络速度； 4、每秒可以处理10万级别写和读； 5、api支持所有语言
redis学习路线
heihei
05-31 1096
一. 数据结构与对象 list hash set sorted set string 二. 单机数据库的实现 Redis数据库的实现方法 Redis的事件 Redis客户端和服务端的运行机制 三. 多机数据库的实现 Rentinel 复制（Replication） 集群（Cluster） 四. 独立功能的实现 发布订阅 事务 Lua脚本 排序 二进制位数组 ...
Redis学习笔记.pdf
08-07
Redis学习笔记.pdf 含目录 #资源达人分享计划#
redis学习135646
09-20
fafa
redis学习文档
10-30
系统而全面地描述了 Redis 内部运行机制； 　图示丰富，描述清晰，并给出大量参考信息，是NoSQL数据库开发人员案头必备； 　包括大部分Redis单机特征，以及所有多机特性。
Redis学习手册
04-09
然而在众多产品中能够脱颖而出的却屈指可数，如 Redis、MongoDB、 BerkeleyDB 和 CouchDB 等。由于每种产品所拥有的特征不同，因此它们的应用场景也存在着一定的差 异，下面仅给出简单的说明： 1). BerkeleyDB 是一...
Redis学习笔记整理
11-14
二、 redis学习笔记之数据类型 3 三、 redis学习笔记之排序 11 四、 redis学习笔记之事务 16 五、 redis学习笔记之pipeline 20 六、 redis学习笔记之发布订阅 23 七、 redis学习笔记之持久化 28 八、 redis学习笔记...
redis学习相关资料
04-27
redis学习相关资料 redis命令 redis文档总结 Redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash...
redis学习笔记(详细总结)
10-20
Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。它支持存储的 value 类型相对更多，包括 ...
redis学习笔记Redis.md
01-04
redis学习笔记
Redis学习笔记
03-29
Redis学习笔记.pdf 学习reis命令，入门到精通等，仅供参考
redis学习资料
06-05
redis学习资料
redis学习笔记.zip
10-19
redis学习笔记，学习资料，参考视频https://www.bilibili.com/video/BV1jD4y1Q7tU?p=29
Redis学习思维导图.jpg
最新发布
11-04
"Redis学习思维导图" 这句话表明了一个中心主题，即Redis的学习，并强调了思维导图作为一种学习工具的重要作用。以下是对这句话的扩充： Redis是一个开源的、内存中的数据结构存储系统，它可以用作数据库、缓存和...
redis 学习资料
03-27
redis 安装 集群 部署文档 内含bat启动文件 适合新手了解redis
尚硅谷redis学习笔记
09-08
通过这些引用内容，我们可以得出结论，尚硅谷的Redis学习笔记涵盖了关于Redis的配置和使用的内容，并提供了一些相关的命令和操作示例。<span class="em">1</span><span class="em">2</span><span class="em">3 #### ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值