刘沙河 刘沙河
首页
  • Go语言基础

    • 数据类型
    • 反射
    • Go指针
  • Go语言进阶

    • go泛型
    • go条件编译
    • cgo教程
    • Go协程调度原理及GPM模型
    • Go内存管理
    • Go垃圾回收机制
    • Go语言内存对齐
  • Go语言实现原理

    • channel 实现原理
    • slice 实现原理
    • map 实现原理
    • sync.Mutex 实现原理
    • 乐观锁CAS 实现原理
    • singlefight 实现原理
  • gin框架

    • gin中间件原理
    • gin路由原理
  • gorm

    • GORM介绍和使用
    • GORM_CURD操作指南
  • go测试

    • benchmark基准测试
    • pprof 性能分析
  • python进阶

    • Numpy&Pandas
    • celery分布式任务队列
  • Django

    • Django 常见命令
    • middleware中间件
    • Django缓存系统
    • Django信号系统
    • Django REST Framework
  • Flask

    • Flask基础知识总结
    • Flask-SQLAlchemy
  • 爬虫

    • aiohttp
    • scrapy框架
  • Mysql

    • Mysql存储引擎和索引
    • MySQL主从复制
    • Mysql读写分离
    • 数据库分库分表
    • Mysql锁
    • Mysql事务和MVCC原理
    • 分库分表带来的读扩散问题
  • Redis

    • redis基础和数据类型
    • redis主从架构
    • redis哨兵架构
    • redis集群模式
    • 如何保证缓存和数据库双写一致
    • redis底层数据结构
    • redis分布式锁
  • Elasticsearch

    • es基本概念
    • es基础语法
    • es倒排索引
  • etcd

    • Go操作etcd
    • Raft原理
    • etcd分布式锁
  • kafka

    • 消息队列MQ总结
    • kafka 概述及原理
    • kafka 消费问题记录
    • 零拷贝技术
    • kafka分区规范
  • RabbitMQ

    • rabbitMQ基础
    • Go操作rabbitmq
  • RocketMQ

    • 可靠消息队列 rocketMQ
  • Http&Https

    • http&https
    • TCP和UDP
    • Ping 原理
  • RPC

    • RPC初识
    • grpc初识和实现
  • gRPC

    • grpc 初识
    • grpc 上下文 metadata
    • grpc 健康检查
    • grpc keepalive
    • grpc 命名解析
    • grpc 中间件&拦截器
    • grpc 负载均衡
    • grpc 身份认证
    • grpc 超时重试
    • grpc 链路追踪
    • grpc-gw将gRPC转RESTfu api
    • grpc-gw自定义选项
  • protobuf

    • protobuf 进阶
    • protobuf 编码原理
  • Docker

    • Docker基础
    • Docker常用命令
    • Dockerfile
    • Docker-Compose
    • Docker多阶段构建
    • Docker Config 教程
    • Docker Swarm 教程
    • Docker Stack 教程
    • Docker Buildx 教程
  • k8s

    • k8s 基础概念
    • k8s 集群架构
    • k8s 工作负载
    • Pod 网络
    • Service 网络
    • 外部接入网络
    • 一张图搞懂k8s各种pod
    • k8s 存储抽象
    • mac快速启动k8s
    • 自制申威架构k8s-reloader
  • go-kit

    • go-kit初识
    • go-kit启动http服务
    • go-kit集成gin启动服务
    • go-kit集成grpc和protobuf
    • go-kit中间件
    • go-kit服务注册发现与负载均衡
    • go-kit限流和熔断
    • go-kit链路追踪
    • go-kit集成Prometheus
  • 设计模式

    • 初识设计模式
    • 创建型模式
    • 结构型模式
    • 行为模式
  • 数据结构

    • 时间轮
    • 堆、双向链表、环形队列
    • 队列:优先队列
    • 队列:延迟队列
  • 算法

    • 递归算法
    • 枚举算法
    • 动态规划
    • 回溯算法
    • 分治算法
    • 贪心算法
    • LRU和LFU
    • 一致性哈希

花开半夏,半夏花开
首页
  • Go语言基础

    • 数据类型
    • 反射
    • Go指针
  • Go语言进阶

    • go泛型
    • go条件编译
    • cgo教程
    • Go协程调度原理及GPM模型
    • Go内存管理
    • Go垃圾回收机制
    • Go语言内存对齐
  • Go语言实现原理

    • channel 实现原理
    • slice 实现原理
    • map 实现原理
    • sync.Mutex 实现原理
    • 乐观锁CAS 实现原理
    • singlefight 实现原理
  • gin框架

    • gin中间件原理
    • gin路由原理
  • gorm

    • GORM介绍和使用
    • GORM_CURD操作指南
  • go测试

    • benchmark基准测试
    • pprof 性能分析
  • python进阶

    • Numpy&Pandas
    • celery分布式任务队列
  • Django

    • Django 常见命令
    • middleware中间件
    • Django缓存系统
    • Django信号系统
    • Django REST Framework
  • Flask

    • Flask基础知识总结
    • Flask-SQLAlchemy
  • 爬虫

    • aiohttp
    • scrapy框架
  • Mysql

    • Mysql存储引擎和索引
    • MySQL主从复制
    • Mysql读写分离
    • 数据库分库分表
    • Mysql锁
    • Mysql事务和MVCC原理
    • 分库分表带来的读扩散问题
  • Redis

    • redis基础和数据类型
    • redis主从架构
    • redis哨兵架构
    • redis集群模式
    • 如何保证缓存和数据库双写一致
    • redis底层数据结构
    • redis分布式锁
  • Elasticsearch

    • es基本概念
    • es基础语法
    • es倒排索引
  • etcd

    • Go操作etcd
    • Raft原理
    • etcd分布式锁
  • kafka

    • 消息队列MQ总结
    • kafka 概述及原理
    • kafka 消费问题记录
    • 零拷贝技术
    • kafka分区规范
  • RabbitMQ

    • rabbitMQ基础
    • Go操作rabbitmq
  • RocketMQ

    • 可靠消息队列 rocketMQ
  • Http&Https

    • http&https
    • TCP和UDP
    • Ping 原理
  • RPC

    • RPC初识
    • grpc初识和实现
  • gRPC

    • grpc 初识
    • grpc 上下文 metadata
    • grpc 健康检查
    • grpc keepalive
    • grpc 命名解析
    • grpc 中间件&拦截器
    • grpc 负载均衡
    • grpc 身份认证
    • grpc 超时重试
    • grpc 链路追踪
    • grpc-gw将gRPC转RESTfu api
    • grpc-gw自定义选项
  • protobuf

    • protobuf 进阶
    • protobuf 编码原理
  • Docker

    • Docker基础
    • Docker常用命令
    • Dockerfile
    • Docker-Compose
    • Docker多阶段构建
    • Docker Config 教程
    • Docker Swarm 教程
    • Docker Stack 教程
    • Docker Buildx 教程
  • k8s

    • k8s 基础概念
    • k8s 集群架构
    • k8s 工作负载
    • Pod 网络
    • Service 网络
    • 外部接入网络
    • 一张图搞懂k8s各种pod
    • k8s 存储抽象
    • mac快速启动k8s
    • 自制申威架构k8s-reloader
  • go-kit

    • go-kit初识
    • go-kit启动http服务
    • go-kit集成gin启动服务
    • go-kit集成grpc和protobuf
    • go-kit中间件
    • go-kit服务注册发现与负载均衡
    • go-kit限流和熔断
    • go-kit链路追踪
    • go-kit集成Prometheus
  • 设计模式

    • 初识设计模式
    • 创建型模式
    • 结构型模式
    • 行为模式
  • 数据结构

    • 时间轮
    • 堆、双向链表、环形队列
    • 队列:优先队列
    • 队列:延迟队列
  • 算法

    • 递归算法
    • 枚举算法
    • 动态规划
    • 回溯算法
    • 分治算法
    • 贪心算法
    • LRU和LFU
    • 一致性哈希
  • Mysql

  • Redis

    • redis基础和数据类型
    • redis缓存穿透、缓存雪崩、缓存击穿
    • redis高阶使用
      • 1. 事务
        • a. 正常执行
        • b. 放弃事务
        • c. 事务执行出错 - 命令错误
        • d. 事务执行出错 - 抛异常
      • 2. 发布与订阅
        • 应用场景
      • 3. 持久化存储
        • 3.1 RDB 持久化 - 快照
        • 3.2 AOF 机制 - 日志
        • 3.3 小结
      • 4. 主从复制
    • 布隆过滤器与缓存穿透
    • redis持久化存储
    • redis线程模型
    • redis过期策略
    • redis主从架构
    • redis哨兵架构
    • redis集群模式
    • redis高并发和高可用
    • 如何保证缓存和数据库双写一致
    • redis为什么那么快
    • redis分布式锁
    • redis事务和watch
    • redis 底层数据结构
  • elasticsearch

  • etcd

  • Database
  • Redis
bigox
2022-06-23
目录

redis高阶使用

# 1. 事务

  • redis可以把一组操作包装在一个事务块中,让这些语句的执行具有原子性

    • multi:开启事务
    • exec:执行事务
    • discard:取消事务
    • watch:监视
  • Redis中的事务原理:就是以multi为起点,在提交之前,先把所有的语句都放在一个队列中,直到exec才做事务的提交

  • 示例

    set user?account 1000
    get user?account
    set user:101:account 10
    get user:101:account
    
    multi
    decrby user?account 500   // 转出500
    incrby user:101:account 500  //转入500
    exec
    
    1
    2
    3
    4
    5
    6
    7
    8
    9

    Redis中,单条命令是原子性执行的,但事务不保证原子性,且没有回滚。事务中任意命令执行失败,其余的命令仍会被执行。

    其中,Redis事务分为三个阶段

    • 开始事务
    • 命令入队
    • 执行事务

# a. 正常执行

image-20220616112854323

# b. 放弃事务

image-20200529212259619

# c. 事务执行出错 - 命令错误

若在事务队列中存在命令性错误(类似于java编译性错误),则执行EXEC命令时,所有命令都不会执行

image-20220616144133889

# d. 事务执行出错 - 抛异常

若在事务队列中存在语法性错误(类似于java的1/0的运行时异常),则执行EXEC命令时,其他正确命令会被执行,错误命令抛出异常

image-20220616144139189

# 2. 发布与订阅

  • redis提供了一个订阅和发布消息的功能,在这个功能中,redis扮演了一个消息路由服务的功能

    • 使用subscribe [channel…] 进行订阅监听,可同时监听多个频道
    • 使用publish [channel] [message] 发送消息到指定的频道
    • 使用**unsubscribe [channel…]**取消监听,可同时取消多个频道
  • redis的订阅/发布性能非常高,可以达到15000/秒次;非常适合用于完成实时消息通知、消息队列等场景;

  • # 应用场景

    • 模拟场景:给id为91的贴点赞,模拟朋友圈

      //设计消息中心
      set post:91:good:message 0
      
      1
      2
    • 设定消息订阅(监听模式)

      127.0.0.1:6379> subscribe post:91:good:massage
      Reading messages... (press Ctrl-C to quit)
      1) "subscribe"
      2) "post:91:good:massage"
      3) (integer) 1
      
      1
      2
      3
      4
      5

      image-20210513103903196

    • 发布消息

      127.0.0.1:6379> publish post:91:good:massage good
      (integer) 1
      
      1
      2
    • 监听窗口收到消息

      127.0.0.1:6379> subscribe post:91:good:massage
      Reading messages... (press Ctrl-C to quit)
      1) "subscribe"
      2) "post:91:good:massage"
      3) (integer) 1
      1) "message"
      2) "post:91:good:massage"
      3) "good"
      
      1
      2
      3
      4
      5
      6
      7
      8

# 3. 持久化存储

  • Redis是一种内存型数据库,一旦服务器进程退出,数据库的数据就会丢失,为了解决这个问题,Redis提供了两种持久化的方案,将内存中的数据保存到磁盘中,避免数据的丢失。

# 3.1 RDB 持久化 - 快照

  • redis提供了RDB持久化的功能,这个功能可以将redis在内存中的的状态保存到硬盘中,它可以手动执行。

  • 也可以再redis.conf中配置,定期执行。

  • RDB持久化产生的RDB文件是一个经过压缩的二进制文件,这个文件被保存在硬盘中,redis可以通过这个文件还原数据库当时的状态。

  • 实战

    1. 触发机制,

      • 手动执行save命令
      • 或者配置触发条件 save 200 10 #在200秒中内,超过10个修改类的操作
    2. 建立redis配置文件,开启rdb功能

      #配置文件  s21_rdb.conf 内容如下 ,有关rdb的配置参数是 	dbfilename  dbmp.rdb  ,一个是 save 900 1   
      
      daemonize yes
      port 6379
      logfile /data/6379/redis.log
      dir /data/6379        #定义持久化文件存储位置
      dbfilename  s21redis.rdb        #rdb持久化文件
      bind  127.0.0.1   		 #redis绑定地址
      requirepass redhat          		  
      save 900 1                  		  
      save 300 10                  	 	
      save  60  10000               		 
      
      save  20  2  #在20秒内,超过2个修改类的操作
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14

# 3.2 AOF 机制 - 日志

  • 第二个机制 aof机制 ,将你的修改类的操作命令,追加到日志文件中

  • AOF 文件中的命令全部以redis协议的格式保存,新命令追加到文件末尾。

  • 优缺点

    • 优点:最大程序保证数据不丢
    • 缺点:日志记录非常大
    redis-client   写入数据  >  redis-server   同步命令   >  AOF文件
    
    1
  • 配置参数

    appendonly yes
    appendfsync  always    总是修改类的操作
                 everysec   每秒做一次持久化
                 no     依赖于系统自带的缓存大小机制
    
    1
    2
    3
    4

1.准备aof配置文件 redis.conf

daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename  dbmp.rdb
requirepass redhat
save 900 1
save 300 10
save 60  10000
appendonly yes
appendfsync everysec
1
2
3
4
5
6
7
8
9
10
11

2.启动redis服务

redis-server /etc/redis.conf
1

3.检查redis数据目录/data/6379/是否产生了aof文件

[root@web02 6379]# ls
appendonly.aof  dbmp.rdb  redis.log
1
2

4.登录redis-cli,写入数据,实时检查aof文件信息

[root@web02 6379]# tail -f appendonly.aof
1

5.设置新key,检查aof信息,然后关闭redis,检查数据是否持久化

redis-cli -a redhat shutdown

redis-server /etc/redis.conf

redis-cli -a redhat
1
2
3
4
5

# 3.3 小结

  • redis 持久化方式有哪些?有什么区别?
    • rdb:基于快照的持久化,速度更快,一般用作备份,主从复制也是依赖于rdb持久化功能
    • aof:以追加的方式记录redis操作日志的文件。可以最大程度的保证redis数据安全,类似于mysql的binlog

# 4. 主从复制

  • 主从复制(Redis2.0就有的功能,主要实现读写分离的):

  • 特点:

    1. master可以拥有多个slave
    2. slave也可以成为其他slave的master(选举机制)
    3. 主从复制是异步的过程,不会产生master和slave的阻塞(这点很优秀)
    4. 在redis中,要实现主从配置非常简单,只需要修改slave的配置,不需要修改master的配置
  • 主从复制过程:

    1. slave与master建立连接,发送sync同步命令
    2. Master会开启一个后台进程,将数据库快照保存到文件中.同时master主进程会执行新的写命令并缓存
    3. 后台完成保存后,就将文件发给slave
    4. Slave将文件保存到硬盘上
#数据库#
上次更新: 2023/04/16, 18:35:33
redis缓存穿透、缓存雪崩、缓存击穿
布隆过滤器与缓存穿透

← redis缓存穿透、缓存雪崩、缓存击穿 布隆过滤器与缓存穿透→

最近更新
01
go与http代理
05-24
02
自制申威架构k8s-reloader
12-06
03
Docker Buildx 教程
12-01
更多文章>
Theme by Vdoing | Copyright © 2020-2024 小刘扎扎 | MIT License
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式