本文共 28338 字，大约阅读时间需要 94 分钟。

redis回顾

redis01 回顾    1，redis基础概念        1，内存型数据库		2，数据结构特别多，kv型存储	    3，单进程单线程    2，通用命令    3，String  字符串类型		1，缓存		2，并发计数		     点赞			 秒杀        3，验证码时效redis02回顾  1，List  重 两边操作  轻  中间操作     场景： 	    1，生产者消费者模型		2，遍历数据  2，hash        1, 压缩特点 【字段数512, 任意value<64字节】	   2，按需获取的特点    场景：	    缓存 		统计计数  3，位图操作    set k1 ab    00000000 00000000     setbit key offset value    对完全不存在的key 直接执行 setbit    setbit k2  0  1    10000000redis03回顾   1，集合       交集差集并集    2，有序集合   score  排行榜   3，事务  - 不保证原子性，报证一定的隔离性        开启事务后，命令进入服务端的命令队列，当服务端exec这个指令时，redis逐一执行命令队列的redis命令		客户端技术 - 流水线        乐观锁 - watch   4, 持久化         rdb           存储：实实在在的数据           触发：save 300 10 		   数据量：全量持久化		 aof           存储：执行的命令           触发: 来一个写入命令，就执行一次           数据量：增量备份

redis_day01笔记

Redis介绍

• 特点及优点

1、开源的，使用C编写，基于内存且支持持久化2、高性能的Key-Value的NoSQL数据库3、支持数据类型丰富，字符串strings，散列hashes，列表lists，集合sets，有序集合sorted sets 等等4、支持多种编程语言（C C++ Python Java PHP ... ）5、单进程单线程

• 与其他数据库对比

1、MySQL : 关系型数据库，表格，基于磁盘，慢2、MongoDB：键值对文档型数据库，值为类似JSON文档，数据结构相对单一3、Redis的诞生是为了解决什么问题？？   # 解决硬盘IO带来的性能瓶颈

• 应用场景

1，缓存2，并发计数	点赞 	秒杀3，排行榜4，生产者消费者模型...

• redis版本

1、最新版本：5.02、常用版本：2.4、2.6、2.8、3.0(里程碑)、3.2、3.4、4.0(教学环境版本)、5.0

• Redis附加功能

1、持久化  将内存中数据保存到磁盘中，保证数据安全，方便进行数据备份和恢复2、过期键功能   为键设置一个过期时间，让它在指定时间内自动删除   
   <节省内存空间>
       # 音乐播放器，日播放排名，过期自动删除3、事务功能   原子的执行多个操作4、主从复制5、Sentinel哨兵
   

安装

• Ubuntu

# 安装sudo apt-get install redis-server# 服务端启动sudo /etc/init.d/redis-server status | start | stop | restart# 客户端连接redis-cli -h IP地址 -p 6379 -a 密码

配置文件详解

• 配置文件所在路径

/etc/redis/redis.confmysql的配置文件在哪里？ : /etc/mysql/mysql.conf.d/mysqld.cnf

• 设置连接密码

1、# 500 requirepass 密码2、重启服务   sudo /etc/init.d/redis-server restart3、客户端连接   redis-cli -h 127.0.0.1 -p 6379 -a 123456   127.0.0.1:6379>ping

• 允许远程连接

1、注释掉本地IP地址绑定  69行: # bind 127.0.0.1 ::12、关闭保护模式(把yes改为no)  88行: protected-mode no3、重启服务  sudo /etc/init.d/redis-server restart

• 通用命令 适用于所有数据类型

#查看redis-server的信息info# 切换库(number的值在0-15之间,db0 ~ db15)select number# 查看键keys 表达式  # keys *# 数据类型type key# 键是否存在exists key# 删除键del key# 键重命名rename key newkey# 清除当前库中所有数据（慎用）flushdb# 清除所有库中所有数据（慎用）flushall

数据类型

字符串类型(string)

• 特点

1、字符串、数字，都会转为字符串来存储2、以二进制的方式存储在内存中

• 字符串常用命令-必须掌握

# 1. 设置一个key-valueset key value# 2. 获取key的值get key# 3. key不存在时再进行设置(nx)set key value nx  # not exists# 4. 设置过期时间(ex)set key value ex seconds# 5. 同时设置多个key-valuemset key1 value1 key2 value2 key3 value3# 6. 同时获取多个key-valuemget key1 key2 key3

• 字符串常用命令-作为了解

# 1.获取长度strlen key# 2.获取指定范围切片内容 [包含start stop]getrange key start stop# 3.从索引值开始，value替换原内容setrange key index value

• 数值操作-字符串类型数字(必须掌握)

# 整数操作incrby key 步长decrby key 步长incr key : +1操作decr key : -1操作# 应用场景: 抖音上有人关注你了，是不是可以用INCR呢，如果取消关注了是不是可以用DECR# 浮点数操作: 自动先转为数字类型，然后再进行相加减，不能使用appendincrbyfloat key step

• string命令汇总

# 字符串操作1、set key value2、set key value nx3、get key3、mset key1 value1 key2 value24、mget key1 key2 key35、set key value nx ex seconds6、strlen key # 返回旧值并设置新值（如果键不存在，就创建并赋值）7、getset key value# 数字操作7、incrby key 步长8、decrby key 步长9、incr key10、decr key11、incrbyfloat key number#(可为正数或负数)# 设置过期时间的两种方式# 方式一1、set key value ex 3# 方式二1、set key value2、expire key 5 # 秒3、pexpire key 5 # 毫秒# 查看存活时间ttl key  -1 ： 当前key存在，没有过期时间  -2 ： 当前key不存在  >0 :  key的剩余时间# 删除过期persist key

• string数据类型注意

# key命名规范可采用 - wang:email# key命名原则1、key名字不宜过长，消耗内存，且在数据中查找这类键值的计算成本高2、不宜过短，可读性较差# 值1、一个字符串类型的值最多能存储512M内容

• 业务场景
  • 缓存
    • 将mysql中的数据存储到redis字符串类型中
  • 并发计数 - 点赞/秒杀
    • 说明：通过redis单进程单线程的特点，由redis负责计数，并发问题转为串行问题
  • 带有效期的验证码 - 短信验证码
    • 借助过期时间，存放验证码；到期后，自动消亡

练习

1、查看 db0 库中所有的键  select 0  keys *2、设置键 trill:username 对应的值为 user001，并查看    set trill:username user001    3、获取 trill:username 值的长度     strlen trill:username        4、一次性设置 trill:password 、trill:gender、trill:fansnumber 并查看（值自定义）      mset trill:password 123 trill:gender M trill:fansnumber 500                5、查看键 trill:score 是否存在    exists trill:score        6、增加10个粉丝    incrby trill:fansnumber 107、增加2个粉丝（一个一个加）    incr trill:fansnumber    incr trill:fansnumber    8、有3个粉丝取消关注你了9、又有1个粉丝取消关注你了10、思考、思考、思考...,清除当前库11、一万个思考之后，清除所有库

列表数据类型（List）

• 特点

1、元素是字符串类型   ['a', 'b', 'c']2、列表头尾增删快，中间增删慢，增删元素是常态3、元素可重复4、最多可包含2^32 -1个元素5、索引同python列表

• 列表常用命令

# 增1、从列表头部压入元素	LPUSH key value1 value2     返回：list长度2、从列表尾部压入元素	RPUSH key value1 value2    返回：list长度3、从列表src尾部弹出1个元素,压入到列表dst的头部	RPOPLPUSH src dst    返回：被弹出的元素4、在列表指定元素后/前插入元素	LINSERT key after|before value newvalue        linsert l1 before a z    返回：		1，如果命令执行成功，返回列表的长度		2，如果没有找到 pivot ，返回 -1		3，如果 key 不存在或为空列表，返回 0 # 查5、查看列表中元素	lrange	LRANGE key start stop  # 查看列表中所有元素: LRANGE key 0 -16、获取列表长度	LLEN key# 删7、从列表头部弹出1个元素	LPOP key8、从列表尾部弹出1个元素	RPOP key9、列表头部,阻塞弹出,列表为空时阻塞	BLPOP key timeout10、列表尾部,阻塞弹出,列表为空时阻塞	BRPOP key timeout  # 关于BLPOP 和 BRPOP  	1、如果弹出的列表不存在或者为空，就会阻塞	2、超时时间设置为0，就是永久阻塞，直到有数据可以弹出	3、如果多个客户端阻塞再同一个列表上，使用First In First Service原则，先到先服务11、删除指定元素	LREM key count value    count>0：表示从头部开始向表尾搜索，移除与value相等的元素，数量为count	count<0：表示从尾部开始向表头搜索，移除与value相等的元素，数量为count	count=0：移除表中所有与value相等的值    返回：被移除元素的数量    12、保留指定范围内的元素	LTRIM key start stop    返回：ok    样例：  		LTRIM mylist1 0 2 # 只保留前3条  		# 应用场景: 保存微博评论最后500条  		LTRIM weibo:comments 0 499# 改13、将列表 key 下标为 index 的元素的值设置为 value	LSET key index newvalue

练习

1、查看所有的键   #keys *2、向列表 spider:urls 中以RPUSH放入如下几个元素：01_baidu.com、02_taobao.com、03_sina.com、04_jd.com、05_xxx.com    #rpush spider:urls 01_baidu.com 02_taobao.com 03_sina.com 04_jd.com 05_xxx.com    3、查看列表中所有元素   #lrange spider:urls 0 -14、查看列表长度   #llen spider:urls5、将列表中01_baidu.com 改为 01_tmall.com   #lset spider:urls 0 01_tmall.com6、在列表中04_jd.com之后再加1个元素 02_taobao.com   #linsert spider:urls after 04_jd.com 02_taobao.com7、弹出列表中的最后一个元素  # rpop 8、删除列表中所有的 02_taobao.com  # lrem spider:urls 0 02_taobao.com9、剔除列表中的其他元素，只剩前3条  # ltrim spider:urls 0 2

python交互redis

• 模块(redis)

Ubuntu

sudo pip3 install redis

• 使用流程

import redis# 创建数据库连接对象r = redis.Redis(host='127.0.0.1',port=6379,db=0,password='123456')

• 通用命令代码示例

import redis#生成连接对象r = redis.Redis(host='127.0.0.1', port=6379, db=0, password='123456')#无密码#r = redis.Redis(host='127.0.0.1', port=6379, db=0)#基础通用命令#key_list = r.keys('*')#[b'u2', b'username', b'username5', b'l1', b'u1', b'u3', b'z4', b'u4']#print(key_list)#print(r.exists('u1'))#print(r.delete('u1'))

• python操作list

#r.lpush('pyl1', 'a', 'b', 'c', 'd')#[b'd', b'c', b'b', b'a']#print(r.lrange('pyl1', 0, -1))#print(r.rpop('pyl1'))#print(r.ltrim('pyl1', 0, 1))#print(r.lrange('pyl1',0, -1))

list案例: 一个进程负责生产任务，一个进程负责消费任务

进程1: 生产者

#生产者import redisr = redis.Redis(host='127.0.0.1', port=6379, db=0, password='123456')# 任务类别/收件人/发件人/内容s = '%s_%s_%s_%s'%('sendEmail', 'guoxiaonao@tedu.cn', 'guo@tedu.cn','hahaha')#任务发到redis的原则  先进先出[lpush, brpop]r.lpush('pylt1', s)

进程2: 消费者

#消费者import redisr = redis.Redis(host='127.0.0.1', port=6379, db=0, password='123456')while True:    task = r.brpop('pylt1', 10)    #task : (b'pylt1', b'sendEmail_guoxiaonao@tedu.cn_guo@tedu.cn_hahaha')    print(task)    if task:        task_data = task[1]        task_str = task_data.decode()        task_list = task_str.split('_')        print('--receiver task, task type is %s'%(task_list[0]))    else:        print('--no task---')

• python操作string

# r.set('pys1', 'guoxiaonao')# print(r.get('pys1'))#r.mset({'pys2':'guo', 'pys3':'xiao'})#[b'guo', b'xiao']#print(r.mget('pys2','pys3'))#print(r.incr('pys6'))#print(r.incrby('pys6',10))

淘汰策略

1，主动出击

​ 1，将带过期时间的key存到一个独立的字典中

​ 默认每100毫秒进行一次过期扫描

​ 1，在过期字典中随机 20个 key

​ 2，检查过期时间，删除已过期的key

​ 3, 如果过期key 比例 超过 1/4 重复 1-3

​ 默认25ms 超时时间， 避免扫描卡死

问题： 大量key同时过期，redis会有卡顿现象

解决方案： set key value ex 1000 + random.ranint(1,100)

2，惰性删除

​ 1， get 【检查key的过期时间， key过期，直接删除】

​ 2， set maxmemory检查

​ noeviction 拒接写服务，可接受读请求 - 默认配置

​ volatile-lru 尝试淘汰设置了过期时间的key, [最少使用原则]

​ allkeys-lru 尝试淘汰所有key [最少使用原则]

redis_day02笔记

位图操作bitmap

定义

1、位图不是真正的数据类型，它是定义在字符串类型中2、一个字符串类型的值最多能存储512M字节的内容，位上限：2^32# 1MB = 1024KB# 1KB = 1024Byte(字节)# 1Byte = 8bit(位)1_login_20200518 ： 12_login_20200518 :  11_login: [20200518, 20200605]1_login: 1100000000100

强势点

可以实时的进行统计，极其节省空间。官方在模拟1亿2千8百万用户的模拟环境下，在一台MacBookPro上，典型的统计如“日用户数”的时间消耗小于50ms, 占用16MB内存

SETBIT 命令

• 说明：设置某位置上的二进制值

• 语法：SETBIT key offset value

• 参数：offset - 偏移量 从0开始

  ​ value - 0或者1

• 示例：

# 默认扩展位以0填充127.0.0.1:6379> SET mykey abOK127.0.0.1:6379> GET mykey"ab"127.0.0.1:6379> SETBIT mykey 0 1(integer) 0127.0.0.1:6379> GET mykey"\xe1b"127.0.0.1:6379>

GETBIT 命令

• 说明：获取某一位上的值

• 语法：GETBIT key offset

• 示例：

127.0.0.1:6379> GETBIT mykey 3(integer) 0127.0.0.1:6379> GETBIT mykey 0(integer) 1127.0.0.1:6379>

BITCOUNT 命令

• 说明：统计键所对应的值中有多少个 1
• 语法：BITCOUNT key start end
• 参数：start/end 代表的是 字节索引
• 示例：

127.0.0.1:6379> SET mykey1 abOK127.0.0.1:6379[4]> BITCOUNT mykey(integer) 6127.0.0.1:6379[4]> BITCOUNT mykey 0 0(integer) 3

应用场景案例

# 网站用户的上线次数统计（寻找活跃用户）	用户名为key，上线的天作为offset，上线设置为1# 示例	用户名为 user1:login 的用户，今年第1天上线，第30天上线	SETBIT user1:login 0 1 	SETBIT user1:login 29 1	BITCOUNT user1:login

代码实现

r.setbit('key', 索引位, 1/0)登陆    r.setbit('1_login_2020', 4 ,1)注册：    r.lpush('users', '用户id')	#筛选出 注册用户中， 2020年登录次数超过100次的玩家，发放奖品    for user_id in lrange('users', 0, -1):                key = '%s_login_2020'%(user_id)        login_count = r.bitcount(key)        if login_count > 1:            符号要求

Hash散列数据类型

• 定义

1、由field和关联的value组成的键值对2、field和value是字符串类型3、一个hash中最多包含2^32-1个键值对 (约43亿)

• 优点

1、节约内存空间 - 特定条件下 【1，字段小于512个，2：value不能超过64字节】2、可按需获取字段的值

• 缺点（不适合hash情况）

1，使用过期键功能：键过期功能只能对键进行过期操作，而不能对散列的字段进行过期操作2，存储消耗大于字符串结构

• 基本命令操作

# 1、设置单个字段HSET key field valueHSETNX key field value# 2、设置多个字段HMSET key field1 value field2 value# 3、返回字段个数HLEN key# 4、判断字段是否存在（不存在返回0）HEXISTS key field# 5、返回字段值HGET key field# 6、返回多个字段值HMGET key field filed# 7、返回所有的键值对HGETALL key# 8、返回所有字段名HKEYS key# 9、返回所有值HVALS key# 10、删除指定字段HDEL key field # 11、在字段对应值上进行整数增量运算HINCRBY key filed increment# 12、在字段对应值上进行浮点数增量运算HINCRBYFLOAT key field increment

python操作hash

# 1、更新一条数据的属性，没有则新建hset(name, key, value) # 2、读取这条数据的指定属性， 返回字符串类型hget(name, key)# 3、批量更新数据（没有则新建）属性,参数为字典hmset(name, mapping)# 4、批量读取数据（没有则新建）属性hmget(name, keys)# 5、获取这条数据的所有属性和对应的值，返回字典类型hgetall(name)# 6、获取这条数据的所有属性名，返回列表类型hkeys(name)# 7、删除这条数据的指定属性hdel(name, *keys)

Python代码hash散列

#r.hset('pyh8', 'uname', 'wangweichao')#{b'uname': b'wangweichao'}#print(r.hgetall('pyh8'))#r.hmset('pyh8',{'age':22,'desc':'spider'})#print(r.hgetall('pyh8'))

应用场景：用户维度数据统计

用户维度统计   统计数包括：关注数、粉丝数、喜欢商品数、发帖数   用户为key，不同维度为field，value为统计数   比如关注了5人	 HSET user:10000 fans 5	 HINCRBY user:10000 fans 1

应用场景: 缓存 - redis+mysql+hash组合使用

• 原理

  用户想要查询个人信息1、到redis缓存中查询个人信息2、redis中查询不到，到mysql查询，并缓存到redis3、再次查询个人信息

• 代码实现

  博客   个人主页项目 amysite1  数据库 amysite1   应用user class User	username - char 用户    age - int  个人主页  /user/detail/1   缓存思想： 1，先找缓存中有没有， 2，缓存没有 - 去查数据库/存储缓存 ，3 缓存有数据则直接返回  return 'username %s  age %s'更新请求  /user/update/
       
            /user/update/1?age=20    更新mysql中的age    删除redis缓存数据   from django.http import HttpResponsefrom django.shortcuts import renderfrom .models import Userimport redis# Create your views here.r = redis.Redis(host='127.0.0.1', port=6379, db=0, password='123456')def user_detail(request, user_id):    #1,先查缓存    # 没有： 数据库 -> 数据回写缓存    # 有： 返回缓存内容    cache_key = 'user:%s'%(user_id)    if r.exists(cache_key):        data = r.hgetall(cache_key)        #{b'username':b'guoxiaonao', b'age':b'20'}        new_data = {
       k.decode():v.decode() for k,v in data.items()}        username = new_data['username']        age = new_data['age']        html = 'Cache username is %s age is %s'%(username, age)        return HttpResponse(html)    #无缓存时    try:        user = User.objects.get(id=user_id)    except Exception as e:        print(e)        return HttpResponse('--no user')    username = user.username    age = user.age    html = 'username is %s age is %s' % (username, age)    #更新缓存    r.hmset(cache_key, {
       'username':username, 'age':age})    r.expire(cache_key, 60)    return HttpResponse(html)def user_update(request, user_id):    #/user/update/1?age=30    age = request.GET.get('age', 0)    try:        user = User.objects.get(id=user_id)    except Exception as e:        return HttpResponse('--no user')    user.age = age    user.save()    #删除缓存    cache_key = 'user:%s'%(user_id)    r.delete(cache_key)    return HttpResponse('--update is ok--')
       

集合数据类型（set）

• 特点

1、无序、去重2、元素是字符串类型3、最多包含2^32-1个元素

• 基本命令

# 1、增加一个或者多个元素,自动去重；返回值为成功插入到集合的元素个数SADD key member1 member2# 2、查看集合中所有元素SMEMBERS key# 3、删除一个或者多个元素，元素不存在自动忽略SREM key member1 member2# 4、元素是否存在SISMEMBER key member# 5、随机返回集合中指定个数的元素，默认为1个SRANDMEMBER key [count]# 6、弹出成员SPOP key [count]# 7、返回集合中元素的个数，不会遍历整个集合，只是存储在键当中了SCARD key# 8、把元素从源集合移动到目标集合SMOVE source destination member# 9、差集(number1 1 2 3 number2 1 2 4 结果为3)SDIFF key1 key2 # 10、差集保存到另一个集合中SDIFFSTORE destination key1 key2# 11、交集SINTER key1 key2SINTERSTORE destination key1 key2# 11、并集SUNION key1 key2SUNIONSTORE destination key1 key2

案例: 新浪微博的共同关注

# 需求: 当用户访问另一个用户的时候，会显示出两个用户共同关注过哪些相同的用户# 设计: 将每个用户关注的用户放在集合中，求交集即可# 实现:	user001 = {
   'peiqi','qiaozhi','danni'}	user002 = {
   'peiqi','qiaozhi','lingyang'}  user001和user002的共同关注为:	SINTER user001 user002	结果为: {
   'peiqi','qiaozhi'}

python操作set

#r.sadd('pyset1', 'tom', 'jack')#{b'jack', b'tom'}#print(r.smembers('pyset1'))#r.sadd('pyset2', 'tom', 'lily', 'xixi')#{b'tom'}print(r.sinter('pyset1', 'pyset2'))

有序集合sortedset

• 特点

1、有序、去重2、元素是字符串类型3、每个元素都关联着一个浮点数分值(score)，并按照分值从小到大的顺序排列集合中的元素（分值可以相同）4、最多包含2^32-1元素

• 示例

  一个保存了水果价格的有序集合

分值	2.0	4.0	6.0	8.0	10.0
元素	西瓜	葡萄	芒果	香蕉	苹果

​ 一个保存了员工薪水的有序集合

分值	6000	8000	10000	12000
元素	lucy	tom	jim	jack

​ 一个保存了正在阅读某些技术书的人数

分值	300	400	555	666	777
元素	核心编程	阿凡提	本拉登	阿姆斯特朗	比尔盖茨

• 有序集合常用命令

# 在有序集合中添加一个成员 返回值为 成功插入到集合中的元素个数zadd key score member# 查看指定区间元素（升序)zrange key start stop [withscores]# 查看指定区间元素（降序）zrevrange key start stop [withscores]# 查看指定元素的分值zscore key member# 返回指定区间元素# offset : 跳过多少个元素# count : 返回几个# 小括号 : 开区间  zrangebyscore fruits (2.0 8.0zrangebyscore key min max [withscores] [limit offset count]# 每页显示10个成员,显示第5页的成员信息: # limit 40 10# MySQL: 每页显示10条记录,显示第5页的记录# limit 40,10# limit 2,3   显示: 第3 4 5条记录# 删除成员zrem key member# 增加或者减少分值zincrby key increment member阅读量文章id_read_count 普通集合  ip  文章_阅读量 有序集合  # 返回元素排名zrank key member# 返回元素逆序排名zrevrank key member# 删除指定区间内的元素zremrangebyscore key min max# 返回集合中元素个数zcard key# 返回指定范围中元素的个数zcount key min maxzcount salary 6000 8000 zcount salary (6000 8000# 6000
   
    <=8000zcount salary (6000 (8000#6000
    
     <8000                       # 并集zunionstore destination numkeys key [weights 权重值] [AGGREGATE SUM|MIN|MAX]# zunionstore salary3 2 salary salary2 weights 1 0.5 AGGREGATE MAX# 2代表集合数量,weights之后 权重1给salary,权重0.5给salary2集合,算完权重之后执行聚合AGGREGATE                     # 交集：和并集类似，只取相同的元素zinterstore destination numkeys key1 key2 weights weight AGGREGATE SUM(默认)|MIN|MAX
    
   

python操作sorted set

#r.zadd('pyss1', {'tom':6000,'jim':5000})#[(b'jim', 5000.0), (b'tom', 6000.0)]#print(r.zrange('pyss1',0,-1, withscores=True))#print(r.zrangebyscore('pyss1', '(5000', 7500,  withscores=True))#r.zadd('pyss2', {'tom': 8000})#r.zinterstore('pyss3',('pyss1','pyss2'), aggregate='max')#print(r.zrange('pyss3', 0, -1, withscores=True))

redis_day02回顾

五大数据类型及应用场景

类型	特点	使用场景
string	简单key-value类型，value可为字符串和数字	常规计数（微博数, 粉丝数等功能）
hash	是一个string类型的field和value的映射表，hash特别适合用于存储对象	存储部分可能需要变更的数据（比如用户信息）
list	有序可重复列表	消息队列等
set	无序不可重复列表	存储并计算关系（如微博，关注人或粉丝存放在集合，可通过交集、并集、差集等操作实现如共同关注、共同喜好等功能）
sorted set	每个元素带有分值的集合	各种排行榜

redis_day03笔记

事务

定义：事务指 程序中一系列严密的操作逻辑【sql语句】，所有操作必须全部完成，或者 全部 不完成，不能出现中间状态

转账： 小明转账 200 元 -> 小红

事务的四大特性（ACID）

原子性（Atomicity）: 事务中的操作，要么全都执行成功， 要么全都不执行

一致性(Consistency)：事务执行始得数据从一个状态转换为另一个状态，这个过程保持完整性

隔离性(Isolation) : 当多个并发访问数据库是，多个事务之间相互隔离，不能被其他事务操作所干扰

持久性（Durability）: 事务完成后，对于数据的改变 是永久的

特点

1. 单独的隔离操作：事务中的所有命令会被序列化、按顺序执行，在执行的过程中不会被其他客户端发送来的命令打断2. 不保证原子性：redis中的一个事务中如果存在命令执行失败，那么其他命令依然会被执行，没有回滚机制

事务命令

1、MULTI  # 开启事务          mysql   begin2、命令1  # 执行命令          3、命令2 ... ...4、EXEC  # 提交到数据库执行    mysql   commit4、DISCARD # 取消事务         mysql  'rollback'

使用步骤

# 开启事务127.0.0.1:6379> MULTIOK# 命令1入队列127.0.0.1:6379> INCR n1QUEUED# 命令2入队列127.0.0.1:6379> INCR n2QUEUED# 提交到数据库执行127.0.0.1:6379> EXEC1) (integer) 12) (integer) 1

事务中命令错误处理

# 1、命令语法错误，命令入队失败，直接自动discard退出这个事务  这个在命令在执行调用之前会发生错误。例如，这个命令可能有语法错误（错误的参数数量，错误的命令名）  处理方案：语法错误则自动执行discard案例：127.0.0.1:6379[7]> MULTIOK127.0.0.1:6379[7]> get aQUEUED127.0.0.1:6379[7]> getsss a(error) ERR unknown command 'getsss'127.0.0.1:6379[7]> 127.0.0.1:6379[7]> 127.0.0.1:6379[7]> EXEC(error) EXECABORT Transaction discarded because of previous errors.# 2、命令语法没错，但类型操作有误，则事务执行调用之后失败，无法进行事务回滚   我们执行了一个由于错误的value的key操作（例如对着String类型的value施行了List命令操作）    处理方案：发生在EXEC之后的是没有特殊方式去处理的：即使某些命令在事务中失败，其他命令都将会被执行。案例127.0.0.1:6379> MULTIOK127.0.0.1:6379> set num 10QUEUED127.0.0.1:6379> LPOP numQUEUED127.0.0.1:6379> exec1) OK2) (error) WRONGTYPE Operation against a key holding the wrong kind of value127.0.0.1:6379> get num"10"127.0.0.1:6379>

思考为什么redis不支持回滚？

pipeline 流水线

定义：批量执行redis命令，减少通信io

注意：此为客户端技术

示例

import redis# 创建连接池并连接到redispool = redis.ConnectionPool(host = '127.0.0.1',db=0,port=6379)r = redis.Redis(connection_pool=pool)pipe = r.pipeline()pipe.set('fans',50)pipe.incr('fans')pipe.incrby('fans',100)pipe.execute()

性能对比

# 创建连接池并连接到redispool = redis.ConnectionPool(host = '127.0.0.1',db=0,port=6379)r = redis.Redis(connection_pool=pool)def withpipeline(r):    p = r.pipeline()    for i in range(1000):        key = 'test1' + str(i)        value = i+1        p.set(key, value)    p.execute()def withoutpipeline(r):    for i in range(1000):        key = 'test2' + str(i)        value = i+1        r.set(key, value)

python 操作 redis事务

with r.pipeline(transaction=true) as pipe    pipe.multi()    pipe.incr("books")    pipe.incr("books")    values = pipe.execute()        ->  "multi  incr books  incr books  exec"

watch - 乐观锁

作用： 事务过程中，可对指定key进行监听，命令提交时，若被监听key对应的值未被修改时，事务方可提交成功，否则失败

> watch booksOK> multiOK> incr booksQUEUED> exec  # 事务执行失败(nil)watch之后，再开一个终端进入redis> incr books  # 修改book值(integer) 1

python操作watch

#同时对一个账户进行操作， 当前余额 * 2import redisimport timepool = redis.ConnectionPool(host='127.0.0.1', db=1, port=6379, password='123456')r = redis.Redis(connection_pool=pool)def double_account(user_id):    key = 'account_%s'%(user_id)    with r.pipeline(transaction=True) as pipe:        while True:            try:                #pipe.watch命令 调用后 即刻发给服务器                pipe.watch(key)                value = int(r.get(key))                value *= 2                print('--new value is %s'%(value))                print('--sleep is start')                time.sleep(20)                print('--sleep is over')                pipe.multi()                pipe.set(key, value)                pipe.execute()                break            except redis.WatchError:                print('---value changed')                continue    return int(r.get(key))if __name__ == '__main__':    #account_guoxiaonao    print(double_account('guoxiaonao'))

数据持久化

持久化定义

将数据从掉电易失的内存放到永久存储的设备上

为什么需要持久化

因为所有的数据都在内存上，所以必须得持久化

RDB模式（默认开启）

1、保存真实的数据2、将服务器包含的所有数据库数据以二进制文件的形式保存到硬盘里面3、默认文件名 ：/var/lib/redis/dump.rdb

创建rdb文件的两种方式

**方式一：**redis终端中使用SAVE或者BGSAVE命令

127.0.0.1:6379> SAVEOK# 特点1、执行SAVE命令过程中，redis服务器将被阻塞，无法处理客户端发送的命令请求，在SAVE命令执行完毕后，服务器才会重新开始处理客户端发送的命令请求2、如果RDB文件已经存在，那么服务器将自动使用新的RDB文件代替旧的RDB文件# 工作中定时持久化保存一个文件127.0.0.1:6379> BGSAVEBackground saving started# 执行过程如下1、客户端 发送 BGSAVE 给服务器2、服务器马上返回 Background saving started 给客户端3、服务器 fork() 子进程做这件事情4、服务器继续提供服务5、子进程创建完RDB文件后再告知Redis服务器# 配置文件相关/etc/redis/redis.conf263行: dir /var/lib/redis # 表示rdb文件存放路径253行: dbfilename dump.rdb  # 文件名# 两个命令比较SAVE比BGSAVE快，因为需要创建子进程，消耗额外的内存# 补充：可以通过查看日志文件来查看redis都做了哪些操作# 日志文件：配置文件中搜索 logfilelogfile /var/log/redis/redis-server.log

方式二：设置配置文件条件满足时自动保存（使用最多）

# redis配置文件默认218行: save 900 1219行: save 300 10220行: save 60 10000    表示如果距离上一次创建RDB文件已经过去了300秒，并且服务器的所有数据库总共已经发生了不少于10次修改，那么自动执行BGSAVE命令  1、只要三个条件中的任意一个被满足时，服务器就会自动执行BGSAVE  2、每次创建RDB文件之后，服务器为实现自动持久化而设置的时间计数器和次数计数器就会被清零，并重新开始计数，所以多个保存条件的效果不会叠加    # 该配置项也可以在命令行执行 [不推荐] redis>save 60 10000

RDB缺点

1、创建RDB文件需要将服务器所有的数据库的数据都保存起来，这是一个非常消耗资源和时间的操作，所以服务器需要隔一段时间才创建一个新的RDB文件，也就是说，创建RDB文件不能执行的过于频繁，否则会严重影响服务器的性能2、可能丢失数据

AOF（AppendOnlyFile）

1、存储的是命令，而不是真实数据2、默认不开启# 开启方式（修改配置文件）1、sudo vim /etc/redis/redis.conf  672行: appendonly yes # 把 no 改为 yes  676行: appendfilename "appendonly.aof"2、重启服务  sudo /etc/init.d/redis-server restart

AOF持久化原理及优点

# 原理   1、每当有修改数据库的命令被执行时，    2、因为AOF文件里面存储了服务器执行过的所有数据库修改的命令，所以给定一个AOF文件，服务器只要重新执行一遍AOF文件里面包含的所有命令，就可以达到还原数据库的目的# 优点  用户可以根据自己的需要对AOF持久化进行调整，让Redis在遭遇意外停机时不丢失任何数据，或者只丢失一秒钟的数据，这比RDB持久化丢失的数据要少的多

特殊说明

# 因为  虽然服务器执行一个修改数据库的命令，就会把执行的命令写入到AOF文件，但这并不意味着AOF文件持久化不会丢失任何数据，在目前常见的操作系统中，执行系统调用write函数，将一些内容写入到某个文件里面时，为了提高效率，系统通常不会直接将内容写入硬盘里面，而是将内容放入一个内存缓存区（buffer）里面，等到缓冲区被填满时才将存储在缓冲区里面的内容真正写入到硬盘里# 所以  1、AOF持久化：当一条命令真正的被写入到硬盘里面时，这条命令才不会因为停机而意外丢失  2、AOF持久化在遭遇停机时丢失命令的数量，取决于命令被写入到硬盘的时间  3、越早将命令写入到硬盘，发生意外停机时丢失的数据就越少，反之亦然

策略 - 配置文件

# 打开配置文件:/etc/redis/redis.conf，找到相关策略如下1、701行: alwarys   服务器每写入一条命令，就将缓冲区里面的命令写入到硬盘里面，服务器就算意外停机，也不会丢失任何已经成功执行的命令数据2、702行: everysec（# 默认）   服务器每一秒将缓冲区里面的命令写入到硬盘里面，这种模式下，服务器即使遭遇意外停机，最多只丢失1秒的数据3、703行: no   服务器不主动将命令写入硬盘,由操作系统决定何时将缓冲区里面的命令写入到硬盘里面，丢失命令数量不确定# 运行速度比较always：速度慢everysec和no都很快，默认值为everysec

AOF重写

思考：AOF文件中是否会产生很多的冗余命令？

为了让AOF文件的大小控制在合理范围，避免胡乱增长，redis提供了AOF重写功能，通过这个功能，服务器可以产生一个新的AOF文件  -- 新的AOF文件记录的数据库数据和原由的AOF文件记录的数据库数据完全一样  -- 新的AOF文件会使用尽可能少的命令来记录数据库数据，因此新的AOF文件的提及通常会小很多  -- AOF重写期间，服务器不会被阻塞，可以正常处理客户端发送的命令请求

示例

原有AOF文件	重写后的AOF文件
select 0	SELECT 0
sadd myset peiqi	SADD myset peiqi qiaozhi danni lingyang
sadd myset qiaozhi	SET msg ‘hello tarena’
sadd myset danni	RPUSH mylist 2 3 5
sadd myset lingyang
INCR number
INCR number
DEL number
SET message ‘hello world’
SET message ‘hello tarena’
RPUSH mylist 1 2 3
RPUSH mylist 5
LPOP mylist

AOF重写-触发

1、客户端向服务器发送BGREWRITEAOF命令   127.0.0.1:6379> BGREWRITEAOF   Background append only file rewriting started2、修改配置文件让服务器自动执行BGREWRITEAOF命令  auto-aof-rewrite-percentage 100  auto-aof-rewrite-min-size 64mb  # 解释    1、只有当AOF文件的增量大于100%时才进行重写，也就是大一倍的时候才触发        # 第一次重写新增：64M        # 第二次重写新增：128M        # 第三次重写新增：256M（新增128M）

RDB和AOF持久化对比

RDB持久化	AOF持久化
全量备份，一次保存整个数据库	增量备份，一次保存一个修改数据库的命令
保存的间隔较长	保存的间隔默认为一秒钟
数据还原速度快	数据还原速度一般，冗余命令多，还原速度慢
执行SAVE命令时会阻塞服务器，但手动或者自动触发的BGSAVE不会阻塞服务器	无论是平时还是进行AOF重写时，都不会阻塞服务器

# 用redis用来存储真正数据，每一条都不能丢失，都要用always，有的做缓存，有的保存真数据，我可以开多个redis服务，不同业务使用不同的持久化，新浪每个服务器上有4个redis服务，整个业务中有上千个redis服务，分不同的业务，每个持久化的级别都是不一样的。

数据恢复（无需手动操作）

既有dump.rdb，又有appendonly.aof，恢复时找谁？先找appendonly.aof

配置文件常用配置总结

# 设置密码1、requirepass password# 开启远程连接2、bind 127.0.0.1 ::1 注释掉3、protected-mode no  把默认的 yes 改为 no# rdb持久化-默认配置4、dbfilename 'dump.rdb'5、dir /var/lib/redis# rdb持久化-自动触发(条件)6、save 900 17、save 300 10 8、save 60  10000# aof持久化开启9、appendonly yes10、appendfilename 'appendonly.aof'# aof持久化策略11、appendfsync always12、appendfsync everysec # 默认13、appendfsync no# aof重写触发14、auto-aof-rewrite-percentage 10015、auto-aof-rewrite-min-size 64mb# 设置为从服务器16、salveof 
    
    
   

Redis相关文件存放路径

1、配置文件: /etc/redis/redis.conf2、备份文件: /var/lib/redis/*.rdb|*.aof3、日志文件: /var/log/redis/redis-server.log4、启动文件: /etc/init.d/redis-server# /etc/下存放配置文件# /etc/init.d/下存放服务启动文件

Redis主从复制

• 定义

1、一个Redis服务可以有多个该服务的复制品，这个Redis服务成为master，其他复制品成为slaves2、master会一直将自己的数据更新同步给slaves，保持主从同步3、只有master可以执行写命令，slave只能执行读命令

• 作用

1，分担了读的压力（高并发），提高服务能力2，避免单点问题 【如果系统中 一个进程挂掉，整个系统挂掉，即为单点问题】

• 原理

从服务器执行客户端发送的读命令，比如GET、LRANGE、SMEMMBERS、HGET、ZRANGE等等，客户端可以连接slaves执行读请求，来降低master的读压力

• 实现方式

  • 方式一（Linux命令行实现）

    redis-server --slaveof --masterauth

    # 从服务端redis-server --port 6300 --slaveof 127.0.0.1 6379# 从客户端redis-cli -p 6300127.0.0.1:6300> keys * # 发现是复制了原6379端口的redis中数据127.0.0.1:6300> set mykey 123(error) READONLY You can't write against a read only slave.127.0.0.1:6300> # 从服务器只能读数据，不能写数据

  • 方式二（Redis命令行实现）

    # 两条命令1、>slaveof IP PORT2、>slaveof no one# 服务端启动redis-server --port 6301# 客户端连接tarena@tedu:~$ redis-cli -p 6301127.0.0.1:6301> keys *1) "myset"2) "mylist"127.0.0.1:6301> set mykey 123OK# 切换为从127.0.0.1:6301> slaveof 127.0.0.1 6379OK127.0.0.1:6301> set newkey 456(error) READONLY You can't write against a read only slave.127.0.0.1:6301> keys *1) "myset"2) "mylist" # 再切换为主127.0.0.1:6301> slaveof no oneOK127.0.0.1:6301> set name helloOK

  • 方式三(利用配置文件)

    # 每个redis服务,都有1个和他对应的配置文件# 两个redis服务  1、6379 -> /etc/redis/redis.conf  2、6300 -> /home/tarena/redis_6300.conf# 修改配置文件  vi redis_6300.confslaveof 127.0.0.1 6379port 6300# 启动redis服务redis-server redis_6300.conf# 客户端连接测试redis-cli -p 6300127.0.0.1:6300> hset user:1 username guods(error) READONLY You can't write against a read only slave.

问题：master挂了怎么办？

1、一个Master可以有多个Slaves2、Slave下线，只是读请求的处理性能下降3、Master下线，写请求无法执行4、其中一台Slave使用SLAVEOF no one命令成为Master，其他Slaves执行SLAVEOF命令指向这个新的Master，从它这里同步数据# 以上过程是手动的，能够实现自动，这就需要Sentinel哨兵，实现故障转移Failover操作

演示

1、启动端口6400redis，设置为6379的slave   redis-server --port 6400   redis-cli -p 6400   redis>slaveof 127.0.0.1 63792、启动端口6401redis，设置为6379的slave   redis-server --port 6401   redis-cli -p 6401   redis>slaveof 127.0.0.1 63793、关闭6379redis   sudo /etc/init.d/redis-server stop4、把6400redis设置为master   redis-cli -p 6400   redis>slaveof no one5、把6401的redis设置为6400redis的salve   redis-cli -p 6401   redis>slaveof 127.0.0.1 6400# 这是手动操作，效率低，而且需要时间，有没有自动的？？？

Sentinel哨兵

Redis之哨兵 - sentinel

1、Sentinel会不断检查Master和Slaves是否正常2、每一个Sentinel可以监控任意多个Master和该Master下的Slaves

案例演示

​ **1、**环境搭建

# 共3个redis的服务1、启动6379的redis服务器   	sudo /etc/init.d/redis-server start2、启动6380的redis服务器，设置为6379的从    redis-server --port 6380    tarena@tedu:~$ redis-cli -p 6380    127.0.0.1:6380> slaveof 127.0.0.1 6379    OK3、启动6381的redis服务器，设置为6379的从   	redis-server --port 6381   	tarena@tedu:~$ redis-cli -p 6381   	127.0.0.1:6381> slaveof 127.0.0.1 6379

​ **2、**安装并搭建sentinel哨兵

# 1、安装redis-sentinelsudo apt install redis-sentinel验证: sudo /etc/init.d/redis-sentinel stop# 2、新建配置文件sentinel.confport 26379sentinel monitor tedu 127.0.0.1 6379 1# 3、启动sentinel方式一: redis-sentinel sentinel.conf方式二: redis-server sentinel.conf --sentinel#4、将master的redis服务终止，查看从是否会提升为主sudo /etc/init.d/redis-server stop# 发现提升6381为master，其他两个为从# 在6381上设置新值，6380查看127.0.0.1:6381> set name teduOK# 启动6379，观察日志，发现变为了6381的从主从+哨兵基本就够用了

sentinel.conf解释

# sentinel监听端口，默认是26379，可以修改port 26379# 告诉sentinel去监听地址为ip:port的一个master，这里的master-name可以自定义，quorum是一个数字，指明当有多少个sentinel认为一个master失效时，master才算真正失效sentinel monitor 
    
     
      
      
       #如果master有密码，则需要添加该配置sentinel auth-pass 
        
        
         #master多久失联才认为是不可用了，默认是30秒sentinel down-after-milliseconds 
          
          
         
        
       
      
     
    
   

python获取master

from redis.sentinel import Sentinel#生成哨兵连接sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)#初始化master连接master = sentinel.master_for('tedu', socket_timeout=0.1, db=1)slave = sentinel.slave_for('tedu',socket_timeout=0.1, db=1)#使用redis相关命令master.set('mymaster', 'yes')print(slave.get('mymaster'))

我司 以rdb形式 运行redis 1月有余   这个月期间，由于采用rdb模式，且遇到了几次服务器宕机【关机】，导致数据发生了少面积丢失       接到上级指示，我们要将rdb修改成aof   直接开启了 redis.conf 配置中的  aof功能 且重启了redis    rdb 和 aof 均开启时， 进程启动默认找aof文件 做数据恢复，由于刚启动aof, aof文件为空，启动时以空文件恢复数据，恢复数据时触发rdb,回写rdb

redis配置

【1】修改配置文件    sudo gedit /etc/redis/redis.conf    修改如下2个内容后保存退出:       # bind 127.0.0.1 ::1  把此行注释掉       protected-mode no     把默认的yes改为no       【2】重启redis服务    sudo /etc/init.d/redis-server restart    【3】远程连接测试(在远程机器上)    redis-cli -h IP地址

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QBibF9tn-1623680257962)(redis.assets/redis.jpg)]

新建配置文件sentinel.conf port 26379 sentinel monitor tedu 127.0.0.1 6379 1

3、启动sentinel

方式一: redis-sentinel sentinel.conf

方式二: redis-server sentinel.conf --sentinel #4、将master的redis服务终止，查看从是否会提升为主 sudo /etc/init.d/redis-server stop

发现提升6381为master，其他两个为从

在6381上设置新值，6380查看

127.0.0.1:6381> set name tedu

OK

启动6379，观察日志，发现变为了6381的从

主从+哨兵基本就够用了

sentinel.conf解释```python# sentinel监听端口，默认是26379，可以修改port 26379# 告诉sentinel去监听地址为ip:port的一个master，这里的master-name可以自定义，quorum是一个数字，指明当有多少个sentinel认为一个master失效时，master才算真正失效sentinel monitor 
    
     
      
      
       #如果master有密码，则需要添加该配置sentinel auth-pass 
        
        
         #master多久失联才认为是不可用了，默认是30秒sentinel down-after-milliseconds 
          
          
         
        
       
      
     
    
   

python获取master

from redis.sentinel import Sentinel#生成哨兵连接sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)#初始化master连接master = sentinel.master_for('tedu', socket_timeout=0.1, db=1)slave = sentinel.slave_for('tedu',socket_timeout=0.1, db=1)#使用redis相关命令master.set('mymaster', 'yes')print(slave.get('mymaster'))

我司 以rdb形式 运行redis 1月有余   这个月期间，由于采用rdb模式，且遇到了几次服务器宕机【关机】，导致数据发生了少面积丢失       接到上级指示，我们要将rdb修改成aof   直接开启了 redis.conf 配置中的  aof功能 且重启了redis    rdb 和 aof 均开启时， 进程启动默认找aof文件 做数据恢复，由于刚启动aof, aof文件为空，启动时以空文件恢复数据，恢复数据时触发rdb,回写rdb

redis配置

【1】修改配置文件    sudo gedit /etc/redis/redis.conf    修改如下2个内容后保存退出:       # bind 127.0.0.1 ::1  把此行注释掉       protected-mode no     把默认的yes改为no       【2】重启redis服务    sudo /etc/init.d/redis-server restart    【3】远程连接测试(在远程机器上)    redis-cli -h IP地址

转载地址：https://blog.csdn.net/z_202041/article/details/117913782 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！