Redis教程

redis学习笔记(入门,较详细)

本文主要是介绍redis学习笔记(入门,较详细),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Redis

Nosql

为什么要用Nosql

  • 单机MySQL的年代

    APP->DAL->Mysql

    • 90年代,一个基本的数据的量一般不会太大,单个数据库完全足够

    • 思考:这种情况下,整个网站的瓶颈是什么

      • 数据量如果太大,一个及其放不下了
      • 数据的索引(B+ Tree),一个机器内存也放不下
      • 访问量(读写混合),一个服务器承受不了
  • Memcached(缓存)+Mysql+垂直拆分

    • 网站百分之八十的情况都是在读,每次都要去查询数据库的话就十分的麻烦,所以说我们希望减轻数据的压力,我们可以使用缓存来保证效率

    • 发展过程

      • 优化数据结构和索引-》文件缓存-》Memcached
  • 分库分表+水平拆分

    • 早些年:MylSAM:表锁,十分的影响效率,高并发下就会出现严重的所问题
    • 转战innodb:行锁
    • 慢慢开始使用分库分表来解决写的压力
  • 如今最近的年代

    • 十年时间,世界已经发生了翻天覆地的变化,Mysql等关系型数据库就不够使用了,数据量很多,变化很快

什么是NoSQL

  • Not Only SQL

    • 泛指关系型数据库的,随着web互联网的诞生,传统的关系数据库很难对付web时代,尤其是超大规模的高并发的社区,暴露出来很多难以克服的问题,Nosql在当今时代发展十分徐苏,Redis是发展的最快的,而我们当下必须掌握
    • 很多的数据类型用户的个人信息,社交网络,地理位置,这些数据类型的存储不需要一个固定的格式,不需要多月的操作就可以横向扩展的,Map使用键值对来控制

特点

  • 方便扩展,(数据之间没有关系,很好扩展)

  • 大数据最高性能(Redis一秒写8万次,读取11万,Nosql的缓存记录集,是一种细粒度的缓存,性能会比较高)

  • 数据类型是多样的(不需要实现设计数据库,随取随用,如果是书籍来那个十分的表,很多人就无法设计了)

  • 传统的RDBMS和Nisql

    • 传统的RDBMS

      • 结构化组织
      • SQL
      • 数据和关系都存在单独的表中
      • 操作操作,数据定义语言
      • 严格的一致性
      • 基础的事务
    • Nosql

      • 不仅仅是数据
      • 没有固定的查询语言
      • 键值对存储
      • 最终一致性
      • CAP定理和BASE(异地多活)
      • 高性能,高可用,高可扩展
  • 了解:3V+3高

    • 大数据时代的3V:主要是描述问题的

      • 海量Volume
      • 多样Variety
      • 实时Veiocity
    • 大数据时代的3高:主要是对程序的要求

      • 高并发
      • 高可拓
      • 高性能

阿里巴巴演进分析

Nosql的四大分类

  • KV键值对

    • 新浪:Redis
    • 美团:Redis+Tair
    • 阿里,八度:Redis+memcache
  • 文档型数据库(bson格式和json一样)

    • MongoDb(一般要求掌握)

      • MongoDB是一个基于分布式文件存储的数据库
      • MongoDB是一个介于关系型数据库和非关系型数据库中中间的产品,MongoDB是非关系型数据库中功能最丰富,最像关系型数据库的
  • 列存储数据库

    • HBase
    • 分布式文件系统
  • 图关系数据库

    • 他不是存图形的,放的是关系

Redis入门

概述

  • Redis是什么

    • 远程字典服务
    • 是一个开元的适应ANSI C语言编写,支持网络,可基于内存亦可
  • Redis能干嘛

    • 内存存储,持久化,内存中是断电即失,所以说持久化很重要
    • 效率高,开元用于高速缓存
    • 发布订阅系统
    • 地图信息分析
    • 计时器,计数器
  • 特性

    • 多样的数据类型
    • 持久化
    • 集群
    • 事务
  • 学习中需要用的东西

    • 官网
    • 中文网

安装

  • Windows

    • 下载安装包
  • linux

    • 下载安装包

      redis安装

    • 将安装包放到linux里

    • 解压安装包

      tar -zxvf redis

    • 基本环境的配置

      yum install gcc-c++

    • make

    • Redis的默认安装路径

      usr/local/bin

    • 将Redis配置文件,拷贝到自己创建的文件夹内部

    • redis默认不是后台启动的,修改配置文件

      修改为自动启动

    • 启动Redis服务

      使用客户端试连接
      redis-server hh/redis-conf

    • 使用redis-cli的测试

    • 查看redis的进程是否开启

      ps -ef |grep redis

    • 如何关闭redis服务

      shutdown

    • 再次查看进程

测试性能

  • redis-benchmark是一个压力测试工具,官方自带的性能测试工具

  • redis-benchmark命令参数

    • -h:指定服务器主机名
    • -p:指定服务器端口
    • -s:指定服务器socket
    • -c:指定并发连接数
    • -n:指定请求数
    • -d:以字节的形式指定SET/GET值的大小
    • -k:1=keep alive 0=reconnect
    • -r:SET/GET/INCR使用随机key、SADD使用随机值
    • -p:通过管道传输请求
    • -q:强制退出redis,仅显示query/sec值
    • -csv:以CSV格式输出
    • -l:生成循环,永久执行测试
    • -t:仅运行以逗号分隔的测试命令列表
  • 测试:100个并发连接

基础的知识

  • redis默认有16个数据库

    • 默认使用的是第0个数据库
    • 可以使用select进行切换
    • keys * :查看数据所有的key
    • flushdb:清空当前的数据库
    • flushall:清空所有的数据库
  • ·redis是单线程的

    • 明白redis是很快的,官方表示,redis是基于内存操作,cpu不是redis性能瓶颈,redis的瓶颈是根据机器的内存和网络带宽,既然可以使用单线程来实现,就使用单线程了。所有就使用了单线程了

    • redis是c语言写的,官方提供的数据为100000+的qps,完全不比同样是使用key-value的Memecache差

    • redis为什么单线程还这么快

      • 误区1:高性能的服务器一定是多线程的?
      • 误区2:多线程(cpu上下文会切换)一定比单线程效率高
      • 先去cpu>内存>硬盘的速度要有所了解
      • 核心:redis是将所有的数据全部放在内存中的,所以说使用单线程去操作效率就是最高的,多线程(cpu上下文会切换:耗时的操作),对于内存来说,如果没有上下文切换效就是最高的,多次读写都是在一个cpu上的,在内存情况这个就是最佳方案

五大数据类型

redis-key

后面有不会的命令可以在官网上选择

  • keys *:查看所有的key
  • set:set key
  • exists:判断当前的key是否存在
  • move:移除当前的key
  • expire:设置key的过期时间
  • ttl:查看当前key 的剩余时间
  • type:查看当前key 的类型

String(字符串)

String类似的使用场景:value除了是我们的字符串还可以是我们的数字
(1)计数器
(2)统计多单位的数量
(3)粉丝数
(4)对象的缓存存储

  • 操作字符串

    127.0.0.1:6379> keys *

    1. “name”
    2. “age”
      127.0.0.1:6379> get name
      “hh”
      127.0.0.1:6379> expire name 10
      (integer) 1
      127.0.0.1:6379> ttl name
      (integer) 5
      127.0.0.1:6379> ttl name
      (integer) 2
      127.0.0.1:6379> ttl name
      (integer) -2
      127.0.0.1:6379> keys *
    3. “age”
      127.0.0.1:6379> set key1 v1
      OK
      127.0.0.1:6379> get key1
      “v1”
      127.0.0.1:6379> keys *
    4. “key1”
    5. “age”
      127.0.0.1:6379> append key1 “hello”
      (integer) 7
      127.0.0.1:6379> get key1
      “v1hello”
      127.0.0.1:6379> STRLEN key1
      (integer) 7
      127.0.0.1:6379> get key1
      “v1hello”
      127.0.0.1:6379> append key1 “huhao”
      (integer) 12
      127.0.0.1:6379> get key1
      “v1hellohuhao”
      127.0.0.1:6379> STRLEN key1
      (integer) 12
    • set key1 v1:设置值
    • get key1 :获得值
    • keys *:获得所有的key
    • exists:查看key是否存在
    • append key1 “”:追加字符串
    • STRLEN :获取字符串的长度
  • 步长

    127.0.0.1:6379> set views 0
    OK
    127.0.0.1:6379> get views
    “0”
    127.0.0.1:6379> incr views
    (integer) 1
    127.0.0.1:6379> incr views
    (integer) 2
    127.0.0.1:6379> get views
    “2”
    127.0.0.1:6379> decr views
    (integer) 1
    127.0.0.1:6379> get views
    “1”
    127.0.0.1:6379> incrby views 10
    (integer) 11
    127.0.0.1:6379> incrby views 20
    (integer) 31
    127.0.0.1:6379> decrby views 30
    (integer) 1

    • incr:自增1
    • decr:自减1
    • incrby:可以设置步长,指定增量
    • decrby:可以设置步长,指定减量
  • 字符串范围

    127.0.0.1:6379> set key1 “hi,hh”
    OK
    127.0.0.1:6379> get key1
    “hi,hh”
    127.0.0.1:6379> GETRANGE key1 0 3
    “hi,h”
    127.0.0.1:6379> SETRANGE key1 1 ello
    (integer) 5
    127.0.0.1:6379> get key1
    “hello”
    127.0.0.1:6379> GETRANGE key1 0 -1
    “hello”

    • GETRANGE key1 0 3::截取字符串[0,3]
    • GETRANGE key1 0 -1:截取所有的字符串
    • SETRANGE key2 1 xx:替换指定位置开始的字符串
  • 设置过期时间

    127.0.0.1:6379> setex key2 30 “hello”
    OK
    127.0.0.1:6379> ttl key2
    (integer) 25
    127.0.0.1:6379> setnx mykey “redis”
    (integer) 1
    127.0.0.1:6379> keys *

    1. “mykey”
    2. “key1”
    3. “key2”
      127.0.0.1:6379> ttl key2
      (integer) -2
      127.0.0.1:6379> keys *
    4. “mykey”
    5. “key1”
      127.0.0.1:6379> setnx mykey “mykey”
      (integer) 0
      127.0.0.1:6379> get mykey
      “redis”
    • setex(set with expire):设置过期时间
    • setnx(set if not exist):不存在设置
  • mset和mget

    127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 #同时设置多个值
    OK
    127.0.0.1:6379> keys *

    1. “k2”
    2. “k3”
    3. “k1”
      127.0.0.1:6379> mget k1 k2 k3 #同时获取多个值
    4. “v1”
    5. “v2”
    6. “v3”
      127.0.0.1:6379> msetnx k1 v1 k4 v4 #msetnx是一个原子性的操作,要么一起成功,要么一起失败
      (integer) 0
      127.0.0.1:6379> get k4
      (nil)
    • mset:同时设置多个值
    • mget:同时获取多个值
  • 对象

    127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
    OK
    127.0.0.1:6379> mget user:1:name user:1:age

    1. “zhangsan”
    2. “2”
    • set user:1 {name:zhangsan,age :3}:设置一个user:1对象,值为json字符串保存的一个对象
    • user:{id}:{filed}
  • getset

    127.0.0.1:6379> getset db redis
    (nil)
    127.0.0.1:6379> get db
    “redis”
    127.0.0.1:6379> getset db mdb
    “redis”
    127.0.0.1:6379> get db
    “mdb”

    • 如果不存在值,则返回nil
    • 如果存在值,获取原来的值,并设置新的值

List(列表)

实际上是一个链表,before Node after,left,right都可以插入值
(1)如果key不存在,创建新的链表
(2)如果key存在,新增内容
(3)如果移除了所有值,空链表,也代表不存在
(4)在两边插入或者改动值,效率最高,中间元素,相对来说效率会低一点

消息排队,消息队列(Lpush,Rpush),栈(Lpush,Lpop)

  • 存入与读取

    127.0.0.1:6379> LPUSH list one
    (integer) 1
    127.0.0.1:6379> LPUSH list two
    (integer) 2
    127.0.0.1:6379> LPUSH list three
    (integer) 3
    127.0.0.1:6379> LRANGE list 0 -1

    1. “three”
    2. “two”
    3. “one”
      127.0.0.1:6379> LRANGE list 0 1
    4. “three”
    5. “two”
      127.0.0.1:6379> RPUSH list four
      (integer) 4
      127.0.0.1:6379> LRANGE list 0 -1
    6. “three”
    7. “two”
    8. “one”
    9. “four”
    • LPUSH:将一个值或者多个值,插入到列表的头部(左)
    • RPUSH:将一个值或者多个值,插入到列表的头部(右)
    • LRANGE:通过区间获取具体的值
  • 移除

    127.0.0.1:6379> lpop list
    “three”
    127.0.0.1:6379> rpop list
    “four”
    127.0.0.1:6379> lrange list 0 -1

    1. “two”
    2. “one”
    • LPOP:移除list 的第一个元素
    • RPOP:移除list的最后一个元素
  • 获取指定值

    127.0.0.1:6379> lrange list 0 -1

    1. “two”
    2. “one”
      127.0.0.1:6379> lindex list 1
      “one”
    • lindex:通过下表获取list中的某一个值
  • 获取长度

    127.0.0.1:6379> Llen list
    (integer) 2

    • Llen:返回list长度
  • 移除指定元素

    127.0.0.1:6379> lrange list 0 -1

    1. “three”
    2. “three”
    3. “two”
    4. “one”
      127.0.0.1:6379> lrem list 1 three
      (integer) 1
      127.0.0.1:6379> lrange list 0 -1
    5. “three”
    6. “two”
    7. “one”
      127.0.0.1:6379> lrem list 0 -1
      (integer) 0
      127.0.0.1:6379> lrem list 1 three
      (integer) 1
      127.0.0.1:6379> lrange list 0 -1
    8. “two”
    9. “one”
    • lrem:移除list集合中的指定个数value
  • 截断

    127.0.0.1:6379> keys *
    (empty array)
    127.0.0.1:6379> rpush list “hello”
    (integer) 1
    127.0.0.1:6379> rpush list “hello1”
    (integer) 2
    127.0.0.1:6379> lpush list “hello2”
    (integer) 3
    127.0.0.1:6379> lpush list “hello3”
    (integer) 4
    127.0.0.1:6379> lrange list 0 -1

    1. “hello3”
    2. “hello2”
    3. “hello”
    4. “hello1”
      127.0.0.1:6379> ltrim list 1 2
      OK
      127.0.0.1:6379> lrange list 0 -1
    5. “hello2”
    6. “hello”
    • trim:修剪

      • ltrim:通过下标截取指定长度,这个list已经被改变了,截断了只剩下截取的元素
  • lpoplpush:移除列表中的最后一个元素,将他移动到新的列表当中

    127.0.0.1:6379> rpush list “hello”
    (integer) 1
    127.0.0.1:6379> rpush list “hello1”
    (integer) 2
    127.0.0.1:6379> rpush list “hello2”
    (integer) 3
    127.0.0.1:6379> rpoplpush list otherlist
    “hello2”
    127.0.0.1:6379> lrange list 0 -1

    1. “hello”
    2. “hello1”
      127.0.0.1:6379> lrange otherlist 0 -1
    3. “hello2”
  • lset:将列表中指定下标的值替换为另外一个值,更新操作

    127.0.0.1:6379> lpush list value1
    (integer) 1
    127.0.0.1:6379> lrange list 0 0

    1. “value1”
      127.0.0.1:6379> lset list 0 item
      OK
      127.0.0.1:6379> lrange list 0 0
    2. “item”
  • linsert:将某个具体的value插入到某个值的前面或者后面

    127.0.0.1:6379> rpush list “hello”
    (integer) 1
    127.0.0.1:6379> rpush list “hello”
    (integer) 2
    127.0.0.1:6379> linsert list after “hello” “world”
    (integer) 3
    127.0.0.1:6379> lrange list 0 -1

    1. “hello”
    2. “world”
    3. “hello”
      127.0.0.1:6379> linsert list before “hello” “hh”
      (integer) 4
      127.0.0.1:6379> lrange list 0 -1
    4. “hh”
    5. “hello”
    6. “world”
    7. “hello”

Set(集合)

Set的值不能重复

微薄,A用户将所有关注的人放在一个set集合中,将他的粉丝也放在一个集合中
共同关注,共同爱好,二度好友,推荐好友(六度分割理论)

  • 添加,查看,判断是否存在

    127.0.0.1:6379> sadd set “hello”
    (integer) 1
    127.0.0.1:6379> sadd set “hefei”
    (integer) 1
    127.0.0.1:6379> sadd set “world”
    (integer) 1
    127.0.0.1:6379> smembers set

    1. “hefei”
    2. “hello”
    3. “world”
      127.0.0.1:6379> sismember set hello
      (integer) 1
      127.0.0.1:6379> sismember set hu
      (integer) 0
    • add:set集合中添加元素
    • smember:查看指定set的所有值
    • sismember:判断某一个值是不是set集合中
  • 元素个数

    127.0.0.1:6379> scard set
    (integer) 3

    • scrad:获取set集合中的元素的个数
  • 移除

    127.0.0.1:6379> srem set hello
    (integer) 1
    127.0.0.1:6379> scard set
    (integer) 2
    127.0.0.1:6379> smembers set

    1. “hefei”
    2. “world”
    • srem:移除set集合中的指定元素
  • 随机抽取

    127.0.0.1:6379> smembers set

    1. “hefei”
    2. “world”
      127.0.0.1:6379> SRANDMEMBER set
      “hefei”
      127.0.0.1:6379> SRANDMEMBER set
      “world”
    • srandmember:随机抽选出一个元素
  • 随机删除

    127.0.0.1:6379> smembers set

    1. “hefei”
    2. “world”
      127.0.0.1:6379> spop set
      “hefei”
      127.0.0.1:6379> smembers set
    3. “world”
    • spop:随机删除一些set集合中的元素
  • 将一个指定的值,移动到另外的集合中

    127.0.0.1:6379> sadd set hello
    (integer) 1
    127.0.0.1:6379> sadd myset hello
    (integer) 1
    127.0.0.1:6379> smove set myset “world”
    (integer) 1
    127.0.0.1:6379> scard myset
    (integer) 2
    127.0.0.1:6379> smembers myset

    1. “hello”
    2. “world”
  • 差交并

    127.0.0.1:6379> sadd set1 a
    (integer) 1
    127.0.0.1:6379> sadd set1 b
    (integer) 1
    127.0.0.1:6379> sadd set1 c
    (integer) 1
    127.0.0.1:6379> sadd set2 c
    (integer) 1
    127.0.0.1:6379> sadd set2 d
    (integer) 1
    127.0.0.1:6379> sadd set2 e
    (integer) 1
    127.0.0.1:6379> sdiff set1 set2

    1. “a”
    2. “b”
      127.0.0.1:6379> sinter set1 set2
    3. “c”
      127.0.0.1:6379> sunion set1 set2
    4. “a”
    5. “b”
    6. “d”
    7. “c”
    8. “e”
    • sdiff:差集
    • sinter:交集
    • sunion:并集

Hash(哈希)

Map集合,key-map时候这个值是一个map集合

hash变更的数据user name age,尤其是用户信息之类的,经常变动的信息!hash更适合于对象的存储,String更加适合字符串存储

  • 存,取

    127.0.0.1:6379> hset hash field1 gpp
    (integer) 1
    127.0.0.1:6379> hget hash field1
    “gpp”
    127.0.0.1:6379> hmset hash field1 hello field2 world
    OK
    127.0.0.1:6379> hmget hash field1 field2

    1. “hello”
    2. “world”
      127.0.0.1:6379> hgetall hash
    3. “field1”
    4. “hello”
    5. “field2”
    6. “world”
    • hset:set一个具体的key-value
    • hget:获取一个字段值
    • hmset:设置多个key-value
    • hmget:获取多个字段值
    • hgetall:获取全部的数据
  • 删除

    127.0.0.1:6379> hdel hash field1
    (integer) 1
    127.0.0.1:6379> hgetall hash

    1. “field2”
    2. “world”
    • hdel:删除指定的key-value
  • 获取长度:hlen

    127.0.0.1:6379> hlen hash
    (integer) 1

  • 判断是否存在:hexists

    127.0.0.1:6379> hexists hash field1
    (integer) 0
    127.0.0.1:6379> hexists hash field2
    (integer) 1

  • 获取key or value

    127.0.0.1:6379> hkeys hash

    1. “field2”
      127.0.0.1:6379> hvals hash
    2. “world”
    • hkeys:获得所有的key
    • hvals:获得所有的value
  • 自增,自减

    127.0.0.1:6379> hincrby hash num 1
    (integer) 6
    127.0.0.1:6379> hincrby hash num -1
    (integer) 5

    • hincrby:自增

Zset(有序集合)

在set的基础上,增加了一个值,set k1 v1 zset k1 score1 v1

案例思路:
(1)set排序,存储班级成绩表,工资表排序
(2)普通消息,1,重要消息,2,带权重进行判断
(3)排行榜应用实现

  • 增加

    127.0.0.1:6379> zadd zset 1 one
    (integer) 1
    127.0.0.1:6379> zadd zset 2 two 3 three
    (integer) 2
    127.0.0.1:6379> zrange zset 0 -1

    1. “one”
    2. “two”
    3. “three”
    • zadd:增加值
  • 排序

    127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf

    1. “gpp”
    2. “xiaohong”
    3. “zhangsan”
      127.0.0.1:6379> zrangebyscore salary 0 -1
      (empty array)
      127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores
    4. “gpp”
    5. “500”
    6. “xiaohong”
    7. “2500”
    8. “zhangsan”
    9. “5000”
      127.0.0.1:6379> ZREVRANGE salary 0 -1
    10. “zhangsan”
    11. “gpp”
    • zrangebyscore:显示全部的用户,从小到大
    • zrangebyscore xx withscores:显示全部的用固话并且附带成绩
    • zrevrange:从大到小排序
  • 移除

    127.0.0.1:6379> zrem salary xiaohong
    (integer) 1
    127.0.0.1:6379> zrange salary 0 -1

    1. “gpp”
    2. “zhangsan”
    • zrem:移除有序集合中的元素
  • 获取数量:zcount

    127.0.0.1:6379> zadd set 1 hello
    (integer) 1
    127.0.0.1:6379> zadd set 2 world 3 gpp
    (integer) 2
    127.0.0.1:6379> zcount set 1 3
    (integer) 3

三种特殊数据类型

Geospatial地理位置

朋友的定位,附近的人,打车距离的计算
redis的Geo在redis3.2版本就推出了,这个功能可以推算地理位置的信息,两地之间的信息

  • geoadd:添加地理位置

    127.0.0.1:6379> geoadd china:city 116.40 39.90 beijing
    (integer) 1
    127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai
    (integer) 1
    127.0.0.1:6379> geoadd china:city 106.50 29.53 chongqing 114.05 22.52 shenzhen
    (integer) 2
    127.0.0.1:6379> geoadd china:city 120.16 30.24 hangzhou 108.96 34.26 xian
    (integer) 2

    • 规则:两级无法直接添加,我们一般会下载城市数据,直接通过Java程序一次性导入
    • 参数:key value:(经度,纬度,名称)
  • geopos:获取地理位置

    127.0.0.1:6379> geopos china:city beijing

      1. “116.39999896287918091”
      2. “39.90000009167092543”
        127.0.0.1:6379> geopos china:city chongqing
      1. “106.49999767541885376”
      2. “29.52999957900659211”
  • geodist:两人之间的距离

    127.0.0.1:6379> geodist china:city beijing shanghai
    “1067378.7564”
    127.0.0.1:6379> geodist china:city beijing shanghai km
    “1067.3788”

    • 单位

      • m表示单位为米
      • km表示单位为千米
      • ml表示单位为英里
      • ft表示单位为英尺
  • georadius:找附近的人(半径)

    127.0.0.1:6379> georadius china:city 110 30 1000 km

    1. “chongqing”
    2. “xian”
    3. “shenzhen”
    4. “hangzhou”
      127.0.0.1:6379> georadius china:city 110 30 500 km
    5. “chongqing”
    6. “xian”
      127.0.0.1:6379> georadius china:city 110 30 500 km withdist
      1. “chongqing”
      2. “341.9374”
      1. “xian”
      2. “483.8340”
        127.0.0.1:6379> georadius china:city 110 30 500 km withdist withcoord
      1. “chongqing”
      2. “341.9374”
        1. “106.49999767541885376”
        2. “29.52999957900659211”
      1. “xian”
      2. “483.8340”
        1. “108.96000176668167114”
        2. “34.25999964418929977”
          127.0.0.1:6379> georadius china:city 110 30 500 km withdist withcoord count 1
      1. “chongqing”
      2. “341.9374”
        1. “106.49999767541885376”
        2. “29.52999957900659211”
          127.0.0.1:6379> georadius china:city 110 30 500 km withdist withcoord count 2
      1. “chongqing”
      2. “341.9374”
        1. “106.49999767541885376”
        2. “29.52999957900659211”
      1. “xian”
      2. “483.8340”
        1. “108.96000176668167114”
        2. “34.25999964418929977”
    • withcoord:显示他人的定位信息
    • withdist:显示到中间距离的位置
    • count:筛选出指定的结果
  • georadiusbymember:找出位置的其他元素

    127.0.0.1:6379> georadiusbymember china:city shanghai 400 km

    1. “hangzhou”
    2. “shanghai”
  • geohash:返回一个或多个位置元素的geohash表示(将二维的经纬度转化为一维的字符串,如果两个字符串越接近,那么则距离越近)

    127.0.0.1:6379> geohash china:city beijing chongqing

    1. “wx4fbxxfke0”
    2. “wm5xzrybty0”
  • geo底层的实现原理其实就是Zset,我们可以使用Zset命令来操作geo

    127.0.0.1:6379> zrange china:city 0 -1

    1. “chongqing”
    2. “xian”
    3. “shenzhen”
    4. “hangzhou”
    5. “shanghai”
    6. “beijing”
      127.0.0.1:6379> zrem china:city beijing
      (integer) 1
      127.0.0.1:6379> zrange china:city 0 -1
    7. “chongqing”
    8. “xian”
    9. “shenzhen”
    10. “hangzhou”
    11. “shanghai”

Hyperloglog

如果允许容错,那么一定可以使用Hyperloglog
如果不允许容错,就使用set或者直接的数据类型即可

  • 什么是基数?

    • 基数(不重复的元素),可以接受误差
  • 简介

    • redis2.8.9版本更新了Hyperloglog数据结构,Redis Hyperloglog基数统计的算法
    • 网页的UV(一个人访问一个网站多次,但是还是算作一个人)
    • 传统的方式,set保存用户的id,然后就可以统计set中的元素数量作为标准判断,这个方式如果保存大量的用户id,就会比较麻烦,我们的目的是为了计数,而不是保存用户id
    • 0.81%错误率,统计UV任务,可以忽略不计
    • 优点:占用的内存量固定,2^64种不同的元素计数,只需要用128KB内存,如果要从内存角度来比较的话,Hyperloglog首选
  • 测试使用

    127.0.0.1:6379> pfadd mykey a b c d e f g h i j
    (integer) 1
    127.0.0.1:6379> pfcount mykey
    (integer) 10
    127.0.0.1:6379> pfadd mykey1 i j z x c v b n m
    (integer) 1
    127.0.0.1:6379> pfcount mykey1
    (integer) 9
    127.0.0.1:6379> pfmerge mykey mykey1
    OK
    127.0.0.1:6379> pfcount mykey
    (integer) 15

    • pfadd:创建
    • pfcount:统计元素数量
    • pfmerge:合并两组数据

Bitmaps

  • 位存储

    • 统计疫情感染人数:0 1 0 1 0
    • 统计用户信息,活跃,不活跃,登录,未登录,两个状态,都可以使用Bitmaps
    • Bitmaps位图,数据结构,都是操作二进制位来进行记录,就只有0和1两个状态
    • 365天=365bit 1字节=8bit 46个字节左右
  • 测试

    • 使用bitmaps来记录周一到周日打卡

      127.0.0.1:6379> setbit sign 0 1
      (integer) 0
      127.0.0.1:6379> setbit sign 1 0
      (integer) 0
      127.0.0.1:6379> setbit sign 2 0
      (integer) 0
      127.0.0.1:6379> setbit sign 3 1
      (integer) 0
      127.0.0.1:6379> setbit sign 4 1
      (integer) 0
      127.0.0.1:6379> setbit sign 5 0
      (integer) 0
      127.0.0.1:6379> setbit sign 6 0
      (integer) 0

    • 查看某一天是否打卡

      127.0.0.1:6379> getbit sign 4
      (integer) 1
      127.0.0.1:6379> getbit sign 5
      (integer) 0

    • 统计打卡的天数

      127.0.0.1:6379> bitcount sign
      (integer) 3

事务

redis事务本质

一组命令的集合,一个事务中的所有命令都会被序列化,在事务执行过程中,会按照顺序执行

  • 一次性
  • 顺序性
  • 排他性

redis事务没有隔离级别的概念

redis单条命令保证原子性的,但是事务不保证原子性

所有的命令在事务中,并没有直接的执行,只有发起执行命令的时候才会执行(exec)

redis的事务

  • 开启事务(multi)
  • 命令入队
  • 执行事务(exec)

正常执行事务

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> exec

  1. OK
  2. OK
  3. “v2”
  4. OK

放弃事务

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> discard
OK
127.0.0.1:6379> get k4
(nil)

  • discard

异常问题

  • 编译型异常(代码有问题,命令有错),事务中所有的命令都不会被执行

    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379(TX)> set k1 v1
    QUEUED
    127.0.0.1:6379(TX)> set k2 v2
    QUEUED
    127.0.0.1:6379(TX)> set k3 v3
    QUEUED
    127.0.0.1:6379(TX)> getset k3
    (error) ERR wrong number of arguments for ‘getset’ command
    127.0.0.1:6379(TX)> set k4 v4
    QUEUED
    127.0.0.1:6379(TX)> set k5 v5
    QUEUED
    127.0.0.1:6379(TX)> exec
    (error) EXECABORT Transaction discarded because of previous errors.
    127.0.0.1:6379> get k5
    (nil)

  • 运行时异常(1/0),如果事务队列中存在语法性,那么执行命令的时候,其他命令是一款正常执行的,错误命令抛出异常

    127.0.0.1:6379> set k1 “v1”
    OK
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379(TX)> incr k1
    QUEUED
    127.0.0.1:6379(TX)> set k2 v2
    QUEUED
    127.0.0.1:6379(TX)> set k3 v3
    QUEUED
    127.0.0.1:6379(TX)> exec

    1. (error) ERR value is not an integer or out of range
    2. OK
    3. OK
      127.0.0.1:6379> get k2
      “v2”
      127.0.0.1:6379> get k3
      “v3”

监控(Watch)

    • 悲观锁

      • 很悲观,什么时候都会出问题,无论做什么都会加锁
    • 乐观锁

      • 很乐观,认为什么时候都不会出问题,所以不会上锁,更新数据的时候去判断一下,在此期间是否有人修改过这个数据
      • 获取version
      • 更新的时候比较version
  • redis监视测试

    • 正常执行成功

      127.0.0.1:6379> set money 100
      OK
      127.0.0.1:6379> set out 0
      OK
      127.0.0.1:6379> watch money
      OK
      127.0.0.1:6379> multi
      OK
      127.0.0.1:6379(TX)> decrby money 20
      QUEUED
      127.0.0.1:6379(TX)> incrby out 20
      QUEUED
      127.0.0.1:6379(TX)> exec

      1. (integer) 80
      2. (integer) 20
    • 测试多线程修改值,使用watch可以当做redis的乐观锁操作

      127.0.0.1:6379> multi
      OK
      127.0.0.1:6379(TX)> decrby money 10
      QUEUED
      127.0.0.1:6379(TX)> incrby out 10
      QUEUED
      127.0.0.1:6379(TX)> exec #执行之前,另外一个线程,修改了我们的值,这个时候,就会导致事务执行失败
      (nil)

    • 如果修改失败,获取最新的值就好

      127.0.0.1:6379> unwatch #如果发现事务执行失败就先解锁
      OK
      127.0.0.1:6379> watch money #获取最新的锁,再次监视,select version
      OK
      127.0.0.1:6379> multi
      OK
      127.0.0.1:6379(TX)> decrby money 1
      QUEUED
      127.0.0.1:6379(TX)> incrby money 1
      QUEUED
      127.0.0.1:6379(TX)> exec #比对监视的值是否发生了变化,如果没有变化,那么可以执行成功,如果变了就执行失败

      1. (integer) 989
      2. (integer) 990

Jedis

什么是Jedis

  • 是redis官方推荐的Java连接开发工具,使用Java操作redis中间件。如果你要使用Java操作redis,那么一定要对Jedis十分熟悉

测试

  • 导入对应的依赖

    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.6.0</version>
    </dependency>
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.56</version>
    </dependency>
    
  • 编码测试

    package com.redis;

    import redis.clients.jedis.Jedis;

    public class Testping {
    public static void main(String[] args) {
    //1.new Jedis 对象即可
    Jedis jedis = new Jedis(“127.0.0.1”,6379);
    //Jedis所有的命令就是我们之前学习的所有指令,所有之前的指令学习很重要
    System.out.println(jedis.ping());
    }
    }

    • 连接数据库
    • 操作命令
    • 断开连接

常用api

  • String
  • List
  • Set
  • Hash
  • Zset

事务

SpringBoot整合

说明:在spring boot2.x之后,原来使用的jedis被替换为了lettuce

  • jedis:采用的直连,多个线程操作的话,是不安全的,如果想要避免不安全,使用jedis pool连接池BIO
  • lettuce:采用netty,实例可以再多个线程中进行共享

源码分析

@Bean
@ConditionalOnMissingBean(name = “redisTemplate”)//我们可以自己定义
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
//默认的RedisTemplate没有过多的设置,redis队形都是需要序列化的
//两个泛型都是Object,Object的类型,我们后使用需要强制转换<String,Object>
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
return template;
}

@Bean
@ConditionalOnMissingBean//由于String是redis中最常用的使用类型,所有说单独提出来了一个bean
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}

整合测试

  • 导入依赖

  • 配置连接

    spring.redis.host=127.0.0.1
    spring.redis.port=6379

  • 测试

    • redisTemplate:造作不同的数据类型,api和我们的指令是一样的

      • opsForValue:操作字符串 类似String
      • opsForList:操作字符串 类似String
      • opsForSet
      • opsForHash
      • opsForZSet

Redis.conf详解

启动的时候,就通过配置文件来启动

单位

配置文件unit单位对大小写不敏感

  • k
  • kb
  • m
  • mb
  • g
  • gb

包含

好比我们学习spring,import,include

  • include /path/to/local.conf
  • include /path/to/other.conf

网络

  • bind 127.0.0.1:绑定ip
  • protected-mode yes:保护模式
  • port:端口设置

通用

  • daemonize yes:以守护进程的方式运行,默认是no,我们许哟啊自己开启为yes
  • pidfile /var/run/redis_6379.pid:如果以后台的方式运行,我们就要指定一个pid文件
  • loglevel notice:日志
  • logfile “”:日志的文件位置名
  • databases 16:数据库的数量,默认是16个数据库
  • always-show-log yes:是否总是显示log

快照

持久化,再规定的时间内,执行了多少次操作,则会持久化到文件.rdb.aof
redis是内存数据库,如果没有持久化,那么数据断电及失

  • save 900 1:如果900s内,如果至少有一个1 key进行了修改,我们及通行持久化操作
  • save 300 10:如果300s内,如果至少10 key进行了修改,我们及进行持久化操作
  • stop-writer-on-bgsave-error:持久化如果出错,是否还需要继续工作
  • rdbcompression yes:保存rdb文件的时候,进行错误的检查校验
  • dir ./:rdb文件保存的目录

SECURITY:安全

  • 设置redis的密码

    127.0.0.1:6379> ping
    PONG
    127.0.0.1:6379> config get requirepass #获取redis的密码

    1. “requirepass”
    2. “”
      127.0.0.1:6379> config set requirepass “123” #设置redis的密码
      OK
      127.0.0.1:6379> config get requirepass
    3. “requirepass”
    4. “123” #这里要退出重新启动才能生效
      127.0.0.1:6379> exit
      [root@hhedu01 bin]# redis-cli -p 6379
      127.0.0.1:6379> config get requirepass
      (error) NOAUTH Authentication required.
      127.0.0.1:6379> ping
      (error) NOAUTH Authentication required.
      127.0.0.1:6379> auth 123
      OK
      127.0.0.1:6379> ping
      PONG

限制

  • maxclients 10000:设置连接池上redis的最大客户端的数量

  • maxmemory :redis配置最大的内存容量

  • maxmemory-policy noeviction:内存到达上限之后的处理策略

    • volatile-lru:只对设置了过期时间的key进行LRU(默认值)
    • allkeys-lru:删除lru算法的key
    • volatile-random:随机删除即将过期的key
    • allkeys-random:随机删除
    • volatile-ttl:删除即将过期的
    • noeviction:永不过期,返回错误

APPEND ONLY模式 aof配置

  • appendonly no:默认是不开启aof模式的,默认是使用rdb凡是持久化的,在大部分所有的情况下,rdb完全够用
  • appendfilename “appendonly.aof”:持久化的文件的名字
  • #appendfsync always:每次修改都会sync,消耗性能
  • appendfsync everysec:每秒执行一次sync,可能会丢失这ls的数据
  • appendfsync no:不执行sync,这个时候操作系统自己同步更新数据,速度最快

Redis发布订阅

是什么

  • redis发布订阅(pub/sub)是一种消息通信模式:发送者(pub)发送消息,订阅者(sub)接受消息。微博,关注系统

  • redis客户端可以订阅任意数量的频道

  • 订阅/发布消息图

    • 消息发送者
    • 频道
    • 消息订阅者

命令

  • PSUBSCRIBE pattern[pattern]:订阅一个或多个符合给定模式的频道
  • PUBSUB subcommand [argument [argument…]]:查看订阅与发布者的状态
  • PUBLISH channel message:将信息发送到指定的频道
  • PUNSUBSCRIBE [pattern [pattern…]]:退订所有给定模式的频道
  • SUBSCRIBE channet[channel…]:订阅给定的一个或多个频道的信息
  • UNSUBSCRIBE [channel[channel…]]:指退订给定的频道

原理

  • redis是使用c实现的,通过分析redis源码里的public.c文件,了解发布和订阅机制的底层实现,借此加深对redis的理解
  • redis通过PUBLIC ,SUBSCRIBE和PSUBSCRIBE等命令实现发布和订阅功能
  • 通过SUBCRIBE命令订阅某频道后,redis-server里维护了一个字典,字典的键就是一个个channel,二字典的值则是一个链表,链表中保存了所有订阅这个channel的客户端,SUBSCRIBE命令的关键,就是将客户端添加到给定channel的订阅链表中
  • 通过PUBLISH命令向订阅者发送消息,redis-server会使用给定的频道作为键,在它维护的channel字典中查找记录了订阅这个频道的所有客户端的链表,遍历这个链表,将消息发布给所有订阅者
  • Pub/Sub从字面上理解就是发布和订阅,在redis中,你可以设定对某一个key值进行消息发布及消息订阅,当一个key值上进行了消息发布后,所有订阅它的客户端都会收到相应的消息,这一功能明显的用法是用作实时信息系统,比如普通的即时聊天,群聊等

使用场景

  • 实时消息系统
  • 实时聊天(频道当前聊天室,将信息回显给所有人即可)
  • 订阅,关注系统都是可以的

Redis持久化

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

RDB

在这里插入图片描述

  • 是什么

    • 在指定的时间间隔内将内存中的数据集快照写入磁盘,也就是航华将的Snapshot快照,他恢复时是将快照文件直接读到内存里
    • Redis会单独创建一个子进程来进行持久化,会先将数据写入到一个临时文件中,待持久化过程都结束了,再用这个临时文件替换上次持久化好的文件,整个过程中,主进程是不进行任何O操作的,这就确保了极高的性能,如果需要进行大规模数据的恢复,且对于数据恢复的完整性不是非常敏感,那RDB方式要比AOF方式更加高效,RDB缺点是最后一次持久化后的数据可能丢失,我们默认的就是RDB,一般情况下不需要修改这个配置
    • rdb保存的文件是dump.rdb 都是在我们的配置文件中快照中进行配置的
  • 触发机制

    • save的规则满足的情况下,会自动出发rdb规则
    • 执行flushall命名,也会触发我们的rdb规则
    • 退出redis,也会产生rdb文件
  • 如果恢复rdb文件

    • 只需要将rdb文件放在我们的redis启动目录就可以了,redis启动的时候会自动检查dump.rdb恢复其中的数据
    • 查看需要存在的位置
  • 优点

    • 适合大规模的数据恢复
    • 对数据的完整性要求不高
  • 缺点

    • 需要一定时间间隔进行操作,如果redis意外宕机了,这个最后一次修改数据就没有的了
    • fork进程的时候,会占用一定的内存空间

AOF(Append Only File)

在这里插入图片描述

  • 是什么

    • 以日志的形式来记录每个写操作,将redis执行过的所有指令记录下来(该操作不记录),只许追加文件但不考研改写文件,redis启动之初会读取改文件重新构建的数据,换言之,redis重启的话就根据日志文件的内容将指令从前到后,执行一次以完成数据的恢复工作
    • Aof保存的是appendonly.aof文件
  • append

    • 默认是不开启的,需要手动配置,我们只需要将appendonly改为yes开启了aof
    • 如果这个aof 文件有错误,这时候redis是启动不起来的,我们需要修复这个aof文件,redis给我们提供了一个工具redis-check-aof --fix
    • 如果aof文件大于64m,fork一个新的进程来将我们的文件进行重写
  • 优点

    • 每一次修改都同步,文件的完整会更加好
    • 每秒同步一次,可能会丢失一秒的数据
    • 从不同步,效率最高的
  • 缺点

    • 相对于数据文件来说,aof远远大于rdb,修复的速度也比rdb慢
    • aof运行效率也要比rdb慢,所有我们redis默认的配置就是rdb持久化
  • 扩展

    • RDB持久化方式能够在指定的时间间隔内对你的数据进行快照存储

    • AOF持久化方式记录每次对服务器写的操作,当服务器重启的时候会重新执行这些命令来恢复原始的数据,AOF命令以redis协议追加八寸每次写的操作到文件末尾,redis还能对AOF文件进行后台重写,使得AIF文件的体积不至于过大

    • 只做缓存,如果你只希望你的数据在服务器运行的时候存在,你也可以不适用任何的持久化

    • 同时开启两种持久化方式

      • 在这种情况下,当redis重启的时候会优先在如AOF来恢复原始的数据,因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整
      • RDB的数据不实时,同时使用两者是服务器重启也只会找AOF文件,那要不要值使用AOF呢?作者建议不要,因为RDB更适合用于备份数据库(AOF在不符按变化不好备份),快速重启,而且不会有AOF可能潜在的bug,留着作为一个万一的手段
    • 性能建议

      • 因为rdb文件只用作后备用途,建议只在Siave上持久化rdb文件,而且只要15分钟备份一次就足够了,值保留save 900 1这条规则
      • 如果Enable AOF,好处在最恶劣情况下也只会丢失不超过两秒的数据,启动脚本较简单值load自己的aof文件就可以了,代价一是带来了持续的IO,二是aof rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的,只要硬盘许可,一个尽量减少aof rewrite的频率,aof重写的基础大小默认值64m太小了,可以射到5G以上,默认超过原大小100%大小重写可以改到适当的数值
      • 如果不Enable aof,仅靠MAster-Slave Repllcation 实现搞可用性也可以,能省掉一大笔IO,也减少rewrite时带来的系统波动,代价是如果Master/Slave同时倒掉,会丢失十几分钟的数据,启动脚本也要比较两个Master/Slave中的rdb文件,载入较新的那个,微博就是这种架构

Redis主从复制

概念

  • 主从复制,是指将一台redis服务器的数据,复制到其他的redis服务器,前者称为主节点,后者称为从节点;数据的复制是单向的,只能由主节点到从节点,Master以写为主,Slave以读为主

  • 默认情况下,每台redis服务器都是主节点;且一个主节点可以有多个从节点,但一个从节点只能由一个主节点,

  • 作用

    • 数据冗余:主从复制实现了数据的热备份,是持久化之外的一种数据的冗余方式
    • 故障恢复,当主节点出现问题时,可以由从节点提供服务,实现快速的故障恢复;实际上市一种服务的冗余
    • 负载均衡:在主从复制的基础上,配合读写分离,可以由主节点提供写服务,由从节点提供读服务,分担服务器负载;尤其是在写少读多的场景下,通过多个从节点分担读负载,可以大大提高redis服务器的并发量
    • 高可用基石:除了上述作用以外,主从复制还是哨兵和集群能能够实施的基础,因此说主从复制是redis高可用的基础
  • 一般来说,要将redis运用于工程项目中,只使用一台redis是万万不能的,原因

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

环境配置

  • 查看当前库的信息

    127.0.0.1:6379> info replication

    Replication

    role:master
    connected_slaves:0
    master_failover_state:no-failover
    master_replid:d3a2c0903dd76f5d42ba1d8572af77d537e92d8d
    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

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

    • 端口
    • pid名字
    • log文件的名字
    • dump.rdb名字
  • 一主二从

    • 默认情况下,每台redis服务器都是主节点:我们一般情况下只用配置从机就好了

      • 从机

        127.0.0.1:6380> slaveof 127.0.0.1 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:7
        master_sync_in_progress:0
        slave_repl_offset:0
        slave_priority:100
        slave_read_only:1
        replica_announced:1
        connected_slaves:0
        master_failover_state:no-failover
        master_replid:ce08ec3f604ba9f9933993a3a21c878a05e6b9ee
        master_replid2:0000000000000000000000000000000000000000
        master_repl_offset:0
        second_repl_offset:-1
        repl_backlog_active:1
        repl_backlog_size:1048576
        repl_backlog_first_byte_offset:1
        repl_backlog_histlen:0

      • 主机

        127.0.0.1:6379> info replication

        Replication

        role:master
        connected_slaves:1
        slave0:ip=127.0.0.1,port=6380,state=online,offset=28,lag=1
        master_failover_state:no-failover
        master_replid:ce08ec3f604ba9f9933993a3a21c878a05e6b9ee
        master_replid2:0000000000000000000000000000000000000000
        master_repl_offset:28
        second_repl_offset:-1
        repl_backlog_active:1
        repl_backlog_size:1048576
        repl_backlog_first_byte_offset:1
        repl_backlog_histlen:28

    • 真实的主从配置是从配置文件里配置,这样配置是永久的

细节

  • 主机可以写,从机不能写只能读,主机中的所有信息和数据,都会自动被从机保存

    • 主机写

      127.0.0.1:6379> keys *
      (empty array)
      127.0.0.1:6379> set k1 v1
      OK

    • 从机只能读取内容

      127.0.0.1:6380> get k1
      “v1”
      127.0.0.1:6380> set k2 v2
      (error) READONLY You can’t write against a read only replica.

  • 主机断开连接,从机依旧能连接到主机,但是没有写操作,这个时候,主机如果回来了,从机依旧可以直接获取到主机写的信息

  • 如果是使用命令行,来配置的主从没这个时候如果重启了,就会变回主机,只要变为从机,立马就会从主机中获取值

复制原理

  • Slave启动成功连接到master后会发送一个sync同步命令
  • Master接到命令,启动后台的存盘进程,同时手机所有接受到的用于修改数据集的命令,在后台进程执行完毕之后,master将传送整个数据文件到slave,并完成一次完全同步
  • 全量复制,二slave访问在接受到数据库文件数据后,将其存盘并加载到内存中
  • 增量辅助:Master继续将新的所有收集到的修改命令依次传给slave,完成同步
  • 但是只要是重新连接master,一次完全同步(全量辅助)将被自动执行,我们的数据一定可以在从机中看到

哨兵模式

概念

  • 一端时间内访问不可用,这不是一种推荐的方式,更多时候,我们优先考虑哨兵模式,redis从2.8开始正式提供了Sentinel(哨兵)架构来解决这个问题
  • 谋朝篡位的自动版,能够后台监控主机是否故障,如果故障了更加投票数动动将从库转化为主库
  • 哨兵模式是一种特殊的模式,首先redis提供了哨兵的命令,哨兵是一个独立的进程,作为进程,它会独立,其原理是哨兵通过发送命令,等待redis服务器响应,从而监控运行多个redis实例

作用

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

多哨兵

  • 一个哨兵进程对redistribution服务器进行监控,可能hi出现问题,为此,我们可以使用多个哨兵进行监控,各个哨兵之间还会进行监控,这就形成了多哨兵模式
  • 假设主服务器宕机,哨兵1先检测到这个结果,系统并不会马上进行fallover过程,仅仅是哨兵1主观的认为主服务器不可用,这个现象称为主观下线,当后面的哨兵也检测到主服务器不可用,并且数量达到一定值是,那么哨兵之间就会进行一次投票,投票的结果由一个哨兵发起,进行fallover故障转移操作,切换成功后,就会通过发布订阅模式,让各个哨兵吧自己监控的从服务器实时切换主机,这个过程称为客观下线

测试

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

    • sentinel monitor myredis 127.0.0.1 6379 1:sentinel monitor 被监控的名称 host port 1

      后面的数字1,代表主机挂了,slave投票看让谁接替称为主机

  • 启动哨兵

  • 如果Master节点断开了,这个时候就会从从机中随机选择一个服务器(这里面有一个投票算法)

  • 如果主机此时回来了,直能归并到主机下,当作从机,这就是哨兵模式的区别

哨兵模式

  • 优点

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

    • redis不好在线扩容,集群容量一旦到达上限,在线扩容就十分麻烦
    • 实现哨兵模式的配置其实是很麻烦的,里面有很多选择

缓存穿透与雪崩

缓存穿透

  • 概念

    • 用户想要查询一个数据,发现redis内存数据库没有,也就是缓存没有命中,于是想持久层数据库查询,发现也没有,于是本次查询失败,当用户很多的时候,缓存都没有命中,于是都去请求了持久化数据库,这会给持久层数据库造成很大的压力,这时候就相当于出现了缓存穿透
  • 解决方案

    • 布隆过滤器

      • 概念

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

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

缓存击穿

  • 概述

    • 缓存击穿是指一个key非常热点,在不停的扛着大并发,大并发集中对这一个点进行访问,当这个key在失效的瞬间,持续的大并发就穿破缓存,直接请求数据库,就像在一个屏障上凿开了一个洞
    • 当某个可以在过期的瞬间,有大量的请求并发访问,这类数据一般是热点数据,由于缓存过期,会同时访问数据库来查询最新数据,并且回写缓存,会导致数据库瞬间压力过大
  • 解决方案

    • 设置热点数据永不过期

      • 从缓存层面来看,没有设置过期时间,所有不会出现热点key过期后产生的问题
    • 加互斥锁

      • 分布式锁:使用分布式锁,保证对于每个key同时只有一个线程去查询后端服务,其他线程没有获得分布式锁的权限,因此值需要等待访问,这种方式将高并发的压力转移到了分布式锁,因此对分布式锁的考研很大

缓存雪崩

  • 概念

    • 缓存雪崩,是指在某一个时间段,缓存集中过期失效,redis宕机
    • 产生雪崩的原因之一,比如在写本文的时候,马上就要到双十二点,很快就会迎来一波抢购,这波商品时间比较集中的放入了缓存,假设缓存一个小时,那么到了凌晨一点的时候,这批商品的缓存就都过期了,而对这批商品的访问查询,都落到了数据库上,对于数据库而言,就会产生周期性的压力波峰,于是所有的请求都会达到存储层,存储层的调用量会暴增,造成存储层也会挂掉的情况
  • 解决方案

    • redis高可用

      • 这个思想的真正意义是,既然redis有可能挂掉,那我多增设几个redis,这样一台挂掉之后其他的还可以工作,其实就是搭建的集群
    • 限流降级

      • 这个解决方案的思想是,在缓存失效后,通过加锁或者队列来控制数据库写缓存的线程数量,比如对莫格key值允许一个线程查询数据和写缓存,其他线程等待
    • 数据预热

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

XMind - Trial Version

这篇关于redis学习笔记(入门,较详细)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!