Redis学习笔记

一、安装Redis

Linux安装(centos7)

1. 安装gcc

由于redis是由C语言编写的，它的运行需要C环境，因此我们需要先安装gcc。安装命令如下：

yum install gcc-c++

2. 下载

wget http://download.redis.io/releases/redis-6.2.5.tar.gz

3.解压

 tar -zxf redis-6.2.5.tar.gz

4. 编译

在解压后的redis包中，进行编译

cd redis-6.2.5/
make

5. 安装redis

cd src/
make install

二、启动

后台启动：通过命令

先进入管理员的根目录,再进入redis目录中的bin目录,然后输入下面的命令

redis-server ../etc/redis.conf

redis-cli

启动客户端与redis建立连接

通过命令查看进程

ps -ef | grep redis

后台启动的好处，即使窗口关掉了，依然可以启动

2.2.6 Redis介绍相关知识

1. Redis默认16个数据库，类似数组下标从0开始，初始默认使用0号库
2. 使用select来切换数据库。如select 8
3. 统一密码管理，所有的库使用相同的密码。
4. dbsize查看当前数据库的key的数量
5. flushdb清空当前数据库
6. flushall通杀全部数据库

Redis是单线程+多路io复用技术

3.1Redis的键(key)

• Redis 中的数据以键值对（key-value）为基本存储方式，其中 key 都是字符串。

1. keys查看当前库所有key(匹配:keys*1)
2. exists key 判断某个key是否存在
3. type key查看你的key是什么类型
4. del key 删除指定key数据
5. unlink key 根据value选择非阻塞删除
6. 仅仅将keys从keyspace元数据中删除,真正的删除会在后续异步操作.
7. expire key 10 10秒钟后:为给指定的key设置过期时间
8. ttl key 查看还有多少秒过时,-1表示永不过时,-2表示已过期

3.2Redis字符串String

3.2.1 简介

• String是Redis最基本的类型

• String类型是二进制安全的.意味着Redis的String可以包含任何数据,比如jpg图片或序列化的对象

• String是Redis最基本的类型,一个Redis中字符串value最多可以是512M.

3.2.2常用命令

1.基本操作

set <key> <value>添加键值对

设置相同的key会覆盖掉前一个key

get <key>查询对应的键值
append <key> <value>将给定的<value>追加到原值的末尾
strlen <key>获得值的长度
setnx <key> <value>只有在key不存在时 设置key的值

setnx <key> <value>只有在key不存在时 设置key的值

设置相同的key不会覆盖掉前一个key,如果key值已经存在则会返回0

incr <key>

• 将key中存储的数字值增1
• 只能对数字值操作,如果为空,新增值为1

decr <key>

• 将key中存储的数字值减1
• 只能对数字值操作,如果为空,新增值为-1

incrby/decrby <key><步长>将key中存储的数字值增减,自定义步长

原子性

1. 所谓原子操作是指不会被线程调度机制打断的操作,这个操作一旦开始,就一直运行到结束,中间不会有任何context switch(切换到另一个线程)
2. 在单线程中,能够在单条指令中完成的操作都可以认为是原子操作,因为中断只能发生在指令之间.
3. 在多线程中,不能被其他进程(线程)打断的操作也叫原子操作.

• Redis单命令的原子性主要得益于Redis的单线程

原子性:有一个失败就都失败

2.String的其他操作

mset <key1><value1><key2><value2>...同时设置一个或多个键值对
mget <key1><key2><key3>...同时获取一个或多个value
msetnx <key1><value1><key2><value2>...同时设置一个或多个键值对,当且仅当所有给定key都不存在
getrange <key><起始位置><结束位置>  获得value值的范围，类似Java中的substring，前包，后包
setrange <key><起始位置><value>  用value覆写<key>所存储的字符串值，从起始位置开始（0），在起始位置插值

setex <key><过期时间><value>  设置键的同时，设置过期时间，单位秒
getset <key><value> 以新换旧，设置了新值同时获得旧值

3.2.3 数据结构

​ String的数据结构为简单动态字符串，是可以修改的字符串，内部结构实现类似于Java的ArrayList，采用预分配冗余空间的方式来减少内存的频繁分配。

3.3Redis列表List

3.3.1 简介

单键多值

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

它的底层实际是个双向链表，对两端的的操作性能都很高，通过索引下标的操作中间的结点性能可能会比较差。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LEizgMRc-1645540236528)(file:///C:\Users\YH925\Documents\Tencent Files\925182704\Image\C2C\9EC3F1C3E21827D80DD35566AE628CC4.jpg)]

3.3.2 常用命令

lpush/rpush <key><value1><value2><value3>...从左边、右边插入一个或多个值

lpop/rpop <key>从左边/右边吐出一个值，值在键在，值亡键亡。

rpoplpush <key1><key2>从<key1>列表右边吐出一个值，插到<key2>列表左边

lrange <key><start><stop>按照索引下标获得元素（从左到右）

lrange <key> 0 -1 查出key列表中所有的值

lindex <key><index>按照索引下标获得元素，从左到右

llen <key>获得指定列表的长度

linsert <key> before <value><newvalue>   在<value>的后面插入<newvalue>插入值

lrem <key><n><value>从左边删除n个value(从左到右)

lset<key><index><value>将列表key下标为index的值替换成value

3.3.3 数据结构

​ List的数据结构为快速链表quickList

首先在列表元素较少的情况下会使用一块连续的内存存储，这个结构是ziplist,也即是压缩列表

它将所有的元素紧挨着一起存储，分配的是一块连续的内存。

当数据量比较多的时候才会改成quickList。

因为普通的链表需要的附加指针空间太大，会比较浪费空间，比如这个列表里存的只是int类型数据，结构上还需要两个额外的指针prev和next。

3.4 Redis集合（Set）

3.4.1简介

Redis set 对外提供的功能与list类似是一个列表的功能，特殊之处在于set是一个可以***自动去重***的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择。并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。

Redis的set是String类型的无序集合。它的底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O（1）。

一个算法，随着数据的增加，执行时间的长短，如果是O（1），数据量增加，查找数据的时间不变。

3.4.2 常用的命令

sadd <key><value1><value2>...将一个或多个member元素加入到集合key中，已经存在的member元素将被忽略

smembers <key>取出该集合中所有的值

sismember <key><value>判断集合<key>是否为含有该<value>值，有则返回1，没有0

scard <key>返回该集合的元素个数

srem <key><value1><value2>...删除集合中的某个元素

spop <key> 随机从该集合中吐出一个值

srandmember <key><n>随机从该集合中取出n个值，不会从集合中删除。

smove <source><destination>value 把集合中的一个值移动到另一个集合中

sinter <key1><key2> 返回两个集合的交集元素。

sunion <key1><key2> 返回两个集合的并集元素

sdiff <key1><key2>返回两个集合的差集元素(在key1中，但是不包含在key2中)

3.4.3 数据结构

​ Set数据结构是dict字典，字典是用哈希表实现的。

Java中的HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。

Redis的set机构也是一样，它的内部也使用hash结构，所有的value都指向同一个内部值。

3.5 Redis哈希（Hash）

3.5.1 简介

Redis hash是一个键值对集合

Redis hash是一个String类型的field和value的映射表，hash特别适用于存储对象。

类似于Java中的Map<String,Object>

用户id为查找的key，存储的value用户对象包含姓名，年龄，生日的信息，如果用普通的key/value结构来存储。

主要有以下2中存储方式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Upu86sTf-1645540236532)(C:\Users\YH925\AppData\Roaming\Typora\typora-user-images\1640261604719.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dyU1i0EU-1645540236533)(C:\Users\YH925\AppData\Roaming\Typora\typora-user-images\1640261633450.png)]

3.5.2 常用命令

hset <key><field><value>  给<key>集合中的<field>键赋值<value>

hget <key1><field>	从集合field中取出value

hmset <key1><field1><value1><field2><value2>...批量设置value的值

hexist <key1><field>	查看哈希表中，给定域field是否存在

hkeys <key>  列出该hash集合中所有field

hvals <key>  列出该hash集合的所有value

hincrby <key><field><increment>  为哈希表key中的域field的值加上增量 1 -1

hsetnx <key><field><value> 将哈希表key中的域field的值设置为value,当且仅当域field不存在

3.5.3 数据结构

​ Hash类型对应的数据结构是两种：ziplist(压缩列表)，hashtable(哈希表)。当field-value长度较短且个数较少时，使用ziplist,否则使用hashtable。

3.6 Redis有序集合Zset(sorted set)

3.6.1 简介

​ Redis有序集合Zset与普通集合set非常相似，是一个没有重复元素的字符串集合。

不同之处在于是：Zset中每个成员都关联了一个评分(score),这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员，集合的成员是唯一的，但是评分可以是重复的。

因为元素是有序的，所以你可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。

访问有序集合的中间元素也是非常快的，因为你能够使用有序集合作为一个没有重复成员的智能列表。

3.6.2 常用命令

zadd <key><score1><value1><score2><value2>...将一个或多个member元素及其score值加入到有序集key中

zrange <key><start><stop>[withscores] 返回有序集key中，下标在<start><stop>之间的元素，
	带withscores，可以让分数一起和值返回到结果集中。
	
zrangebyscore <key> min max[WITHSCORES] [LIMIT offset] 在分数的指定区间内返回数据，从大到小排列

zrevrangebyscore <key> min max[WITHSCORES] [LIMIT offset] 同上，改为从大到小

zincrby <key><increment><value> 为元素的score加上增量

zrem <key><value> 删除该集合下，指定值的元素

zcount <key><min><max>统计该集合，分数区间内的元素个数

zrank <key><value> 返回该值在集合中的排名

---

4.Redis中的配置文件

1.找到redis.conf文件，之前已经修改过文件路径

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N2YzyXG9-1645540236534)(C:\Users\YH925\AppData\Roaming\Typora\typora-user-images\1640314018359.png)]

redis中的一些单位换算

• Redis中支持字节类型，不支持其他类型。大小写不敏感。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m1yTcrzk-1645540236534)(C:\Users\YH925\AppData\Roaming\Typora\typora-user-images\1640314055613.png)]

• include 配置文件中可以包含其他文件，就如同，jsp中的include

4.3网络相关配置

4.3.1 bind

默认情况下bind=127.0.0.1只能接受本机的访问请求

不写的情况下，无限制接受任何ip地址的访问。

生产环境下肯定要写你应用服务器的地址；服务器是需要远程访问的，所以需要将其注释掉。

在network中将下面一行注释，就能支持远程连接

#bind 127.0.0.1 -::1

如果开启了protected-mode，那么在没有设定bind ip且没有设密码的情况下，Redis只允许接受本机大的相应。

protected-mode no
由yes改为no使其支持远程连接

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hiXwDGhk-1645540236535)(C:\Users\YH925\AppData\Roaming\Typora\typora-user-images\1640314186463.png)]

• tcp-keepalive 每隔一段时间检查用户是否处于连接状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-79bSsAPD-1645540236536)(C:\Users\YH925\AppData\Roaming\Typora\typora-user-images\1640314444592.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WHPxdXin-1645540236536)(C:\Users\YH925\AppData\Roaming\Typora\typora-user-images\1640314661296.png)]

5.Redis的发布和订阅

5.1什么是发布和订阅

• Redis发布与发布功能（Pub/Sub）是基于事件座位基本的通信机制，是目前应用比较普遍的通信模型，它的目的主要是解除消息的发布者与订阅者之间的耦合关系。

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

• Redis作为消息发布和订阅之间的服务器，起到桥梁的作用，在Redis里面有一个channel的概念，也就是频道，发布者通过指定发布到某个频道，然后只要有订阅者订阅了该频道，该消息就会发送给订阅者，原理图如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y9Vn2SIn-1645540236537)(C:\Users\YH925\Desktop\20200804214323283.png)]

6.Redis6新特性

6.1 Bitmaps

6.1.1 简介

现代计算机用二进制（位），作为信息的基础单位，1个字节等于8位，例如“abc”字符串是由3个字节组成的，但实际上在计算机存储时将其用二进制表示，“abc”分别对应的ASCII码分别是97,98,99,对应的二进制数分别是

• 01100001
• 01100010
• 01100011

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JoMcn1cI-1645540236538)(file:///C:\Users\YH925\Documents\Tencent Files\925182704\Image\C2C\F8565806EA82E887F876DC7BC9BD18D8.jpg)]

合理的使用操作位能够有效的提高内存使用率和开发效率

Redis提供了Bitmaps这个“数据类型”可以实现对位的操作：

1. Bitmaps本身不是一种数据类型，实际上它就是字符串（key-value),但是它可以对字符串的位进行操作。

2. Bitmaps单独提供了一套命令，所以在Redis中使用Bitmaps和使用字符串的方法不太相同。可以把Bitmaps想象成一个以位为单位的数组，数组的每个单位只能存储0和1，数组的下标在Bitmaps中叫做偏移量。

   key value 011000010110001001100011

6.1.2命令

1.setbit

(1)格式

setbit <key><offset><value>	设置Bitmaps中某个偏移量的值（0或1）

offset偏移量从0开始

（2）实例

​ 每个独立用户是否访问过网站存放在Bitmaps中，将访问过的用户记作1，没有访问过的用户记作0，用偏移量作为用户的id.

​ 设置键的第offset个位的值（从0算起），假设现在有20个用户，userid=1，6，11，15，19的用户对网站进行了访问，那么Bitmaps初始化结果如图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iseiOcTm-1645540236538)(file:///C:\Users\YH925\Documents\Tencent Files\925182704\Image\C2C\5E79B6CE71B1DFD63C98CEF476018A27.jpg)]

🐖：很多应用的用户id以一个指定数字（例如1000）开头，直接将用户id和Bitmaps的偏移量对应会造成浪费，通常做法是每次做setbit操作时，将用户id减去这个指定的数字。

​ 在第一次初始化Bitmaps时，假如偏移量很大，那么整个初始化过程会很慢，可能会造成Redis阻塞。

2.getbit

（1）格式

getbit <key><offset> 获取Bitmaps中某个偏移量的值
offset从0开始，就如同数组下标一样。

（2）实例

获取id=8的用户是否在2020-11-08这天访问过，返回0则代表没有访问过：

getbit unique:user:20201108 8

注：因为id为100的用户不存在，所以也是返回0.

3.bitcount

统计字符串被设置为1的bit数量。一般情况下，给定的整个字符串会被进行计数，通过指定的start和end参数可以让计数只在特定的位上进行。start和end参数的设置，都可以使用负数：比如-1表示最后一位，而-2表示倒数第二位

（1）格式

bitcount<key>[start end] 统计字符串从start字节到end字节

（2）实例

计算2022-11-06这天的访问用户数量。

bitcount unique:user:20221106

4、bitop

(1)格式

bitop and(or/not/xor) [key…]

bitop是一个复合操作， 它可以做多个Bitmaps的and（交集） 、 or（并集） 、 not（非） 、 xor（异或） 操作并将结果保存在destkey中。

(2)实例

2020-11-04 日访问网站的userid=1,2,5,9。

setbit unique:users:20201104 1 1

setbit unique:users:20201104 2 1

setbit unique:users:20201104 5 1

setbit unique:users:20201104 9 1

2020-11-03 日访问网站的userid=0,1,4,9。

setbit unique:users:20201103 0 1

setbit unique:users:20201103 1 1

setbit unique:users:20201103 4 1

setbit unique:users:20201103 9 1

计算出两天都访问过网站的用户数量

bitop and unique:users:and:20201104_03

unique:users:20201103unique:users:20201104

计算出任意一天都访问过网站的用户数量（例如月活跃就是类似这种） ， 可以使用or求并集

6.2HyperLogLog

6.2.1 简介

​ 在工作当中我们经常会遇到与统计相关的需求，比如统计网站pv(PageView页面访问量)，可以使用Redis的incr、incrby轻松实现。

​ 但像uv（UniqueVisitor,独立访客）独立IP数，搜索记录数的需要去重和计数的问题如何解决？这种集合中不重复元素个数的问题称为基数问题。

​ 解决基数问题有很多种方案：

（1）存储在MySQL表中，使用distinct count计算不重复个数。

（2）使用Redis提供的hash、set、bitmaps等数据结构来处理。

以上方案结果精确，但随着数据不断增加，导致占用空间越来越大，对于非常大的数据集是不切实际的。

能否降低一定的精度来平衡存储空间?Redis推出了HyperLogLog

HyperLogLog是用来作基数统计的算法，HyperLogLog的优点是，在输入元素的数量或体积非常大时，计算基数所需的空间总是固定的，并且是很小的。

在Redis里面，每个HyperLogLog键只需花费12kb内存，就可以计算接近2^64个不同元素的基数。这和计算基数时，元素越多消耗内存就越多的集合形成鲜明对比。

但是，因为HyperLogLog只会根据输入元素来计算基数，而不会存储输入元素本身，所以HyperLogLog不能像集合那样，返回输入的元素。

• 什么是基数？

比如数据集{1，3，5，7，5，7，8}，那么这个数据集的基数就是{1，3，5，7，8}，基数（不重复元素）为5.基数估计就是在误差可接受的范围内，快速计算基数。

6.2.2命令

1.pfadd

（1）格式

pfadd <key><element>[element...] 添加指定元素到HyperLogLog中

7.Jedis操作Redis6

通过java操作Redis，，概念与jdbc类似

package com.example.jedis;

import redis.clients.jedis.Jedis;

public class JedisDemo1 {
    public static void main(String[] args) {
        //创建Jedis对象
        Jedis jedis = new Jedis("192.168.0.100",6379);
        //测试
        String ping = jedis.ping();
        System.out.println(ping);
    }
}

如果要联通虚拟机中的Linux系统，需要关闭Linux中的防火墙

systemctl status firewalled查看防火墙命令
systemctl stop firewalld 关闭防火墙命令
开放6379端口号
启动redis服务

7.1 Jedis API

jedis api与redis的常规操作差不多

@Test
    public void demo1(){
        Jedis jedis = new Jedis("192.168.0.104",6379);

        //添加
        jedis.set("k3", "java");

        String k1 = jedis.get("k1");
        System.out.println(k1);

        Set<String> keys = jedis.keys("*");
        for (String key : keys) {
            System.out.println(key);
        }
    }

hello
k3
k1
k2

7.2实例–手机验证码

要求：

1. 输入手机号，点击发送后随机生成6位数数字验证码，2分钟有效
2. 输入验证码，点击验证，返回成功或失败。
3. 每个手机号每天只能输入3次。

1.生成随机6位数字验证码
	**Random
2.验证码在两分钟内有效
	**把验证码放到redis里面，设置过期时间120秒
3.判断验证码是否一致
	**从redis获取验证码和输入的验证码进行比较
4.每个手机号每天只能发送3次验证码
	**incr每次发送后+1
	**大于2的时候，提交不能发送

Java代码

package com.example.jedis;

import redis.clients.jedis.Jedis;

import java.util.Random;

public class PhoneCode {
    public static void main(String[] args) {
        //模拟验证码发送
        //verifyCode("15651192041");
        getRedisCode("15651192041","900249");
    }

    //1.生成6位数字验证码
    public static String getCode(){
        Random random = new Random();
        StringBuilder code = new StringBuilder();
        for (int i = 0; i < 6; i++) {
            int rand = random.nextInt(10);
            code.append(rand);
        }
        return code.toString();
    }

    //2.每个手机号每天只能发送3次验证码
    public static void verifyCode(String phone){
        //连接redis
        Jedis jedis = new Jedis("192.168.0.104",6379);

        //拼接key
        //手机发送次数key
        String countKey = "VerifyCode"+phone+":count";

        //验证码key
        String codeKey = "VerifyCode"+phone+":code";

        //每个手机每天只能发送三次
        String count = jedis.get(countKey);
        if (count == null){
            //没有发送次数，第一次发送
            //设置发送次数是1
            jedis.setex(countKey,24*60*60,"1");
        }else if (Integer.parseInt(count) <= 2){
            //发送次数+1
            jedis.incr(countKey);
        }else if (Integer.parseInt(count) >2){
            //发送次数超过三，不能再发送
            System.out.println("今天发送次数已经超过三次");
            jedis.close();
            return;
        }
        //发送的验证码放到redis里面
        String vcode = getCode();
        jedis.setex(codeKey,120,vcode);
        jedis.close();
    }

    //3.验证码校验
    public static void getRedisCode(String phone,String code){
        //连接redis
        Jedis jedis = new Jedis("192.168.0.104",6379);

        //从redis中获取验证码，再比较
        String codeKey = "VerifyCode"+phone+":code";

        String redisCode = jedis.get(codeKey);
        //判断
        if (redisCode.equals(code)){
            System.out.println("成功");
        }else {
            System.out.println("失败");
        }
        jedis.close();
    }

}

8.Redis事务

8.1Redis事务的定义

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序的执行。事务在执行过程中，不会被其他客户端发送来的命令请求所打断。

Redis事务的主要作用就是串联多个命令防止别的命令插队。

• Redis 中事务，不同于传统的关系型数据库中的事务。
• Redis 中的事务指的是一个单独的隔离操作。
• Redis 的事务中的所有命令都会序列化、按顺序地执行且不会被其他客户端发送来的命令请求所打断。
• Redis 事务的主要作用是串联多个命令防止别的命令插队

8.2 Multi、Exec、discard

从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。

组队的过程中可以通过discard来放弃组队。

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> 
    输入MULTI命令开启事务
    显示tx表示事务已经开启

127.0.0.1:6379(TX)> set key1 value1
QUEUED
127.0.0.1:6379(TX)> 
	表示把set key1 value1命令进行组队，放到QUEUED队列中

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> set key1 value1
QUEUED
127.0.0.1:6379(TX)> set key2 value2
QUEUED
127.0.0.1:6379(TX)> EXEC
1) OK
2) OK
127.0.0.1:6379> 
	输入exec执行队列中的命令，显示两条命令已经完成。此时的事务也已经结束了。如果再次执行事务需要重开MULTI命令
	如果不想执行事务队列了，直接输入discard命令即可。

8.3事务的错误处理

• 组队中某个命令出现了错误报告，执行时整个的所有队列都会被取消。

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
(error) ERR wrong number of arguments for 'set' command
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> 
执行第三个set命令时，故意没有写value值，则整个队列都被销毁。

• 如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚。

127.0.0.1:6379(TX)> set k1 v1
QUEUED
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)> exec
1) OK
2) (error) ERR value is not an integer or out of range
3) OK
127.0.0.1:6379> 
执行第二条命令时，k1 的 value值不是数字类型的不能执行incr命令，所以第二条命令执行失败，其他命令不受影响。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2m31itlH-1645540236539)(C:\Users\YH925\AppData\Roaming\Typora\typora-user-images\1640350480069.png)]

8.4事务冲突的问题

8.4.1 例子

1. 一个请求想给金额减8000
2. 一个请求想给金额减5000
3. 一个请求想给金额减1000

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GRZIfqTb-1645540236539)(file:///C:\Users\YH925\Documents\Tencent Files\925182704\Image\C2C\0578E305FEED176DF8066A94B9AC39E9.jpg)]

8.4.2 悲观锁

定义：每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是做操作之前先上锁。

8.4.3 乐观锁

定义：认为冲突不总是存在的，在执行更新性质的操作的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制，乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7rL9fez8-1645540236540)(file:///C:\Users\YH925\Documents\Tencent Files\925182704\Image\C2C\09BAB0D4260B359A5D765638DC16F17B.jpg)]

8.4.4 watch key [key…]

在执行multi之前，先执行watch key1 [key2].可以监视一个（或多个）key,如果事务在执行之前这个（或这些）key被其他命令所改动，那么事务将被打断。

8.4.5 Redis事务的三特性

• 单独的隔离操作
  • 事务中所有命令都会序列化，按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求打断。
• 没有隔离级别的概念
  • 队列中的命令没有提交之前都不会被实际执行，因为事务提交前任何指令都不会被实际执行
• 不保证原子性
  • 事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚。

9.Redis持久化操作

• RDB
• AOF

9.1RDB

概念：在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是俗称的快照，它恢复时是将快照文件直接读到内存里。

9.1.2 备份是如何执行的

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

9.1.3 Fork

• Fork的作用是复制一个与当前进程一样的进程，新进程的所有数据（变量、环境变量、程序计数器等）数值和原进程一致，但是也是一个全新的进程，并作为原进程的子进程。
• 在Linux程序中fork（）会产生一个和父进程完全相同的子进程，但子进程在此后会多次exec系统调用，出于效率考虑，Linux中引入了写时复制技术。
• 一般情况下父进程和子进程会共同用同一段物理内存，只有进程空间的各段内容要发生变化时，才会将父进程的内容复制一份给子进程。

10.Redis集群

10.1问题

容量不够，redis如何进行扩容

并发写操作，redis如何分摊

另外，主从模式，薪火相传模式，主机宕机，导致IP地址发生变化，应用程序中配置需要修改对应的主机地址，端口等信息。

之前通过代理主机实现，但是redis 3.0 中提供了解决方案。就是无中心化集群配置。

10.2 什么是集群

Redis集群实现了对redis的水平扩容，即启动N个redis节点，将整个数据库分布存储在这N个节点中，每个节点存储总数据的1/N

中的命令没有提交之前都不会被实际执行，因为事务提交前任何指令都不会被实际执行

• 不保证原子性
  • 事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚。

9.Redis持久化操作

• RDB
• AOF

9.1RDB

概念：在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是俗称的快照，它恢复时是将快照文件直接读到内存里。

9.1.2 备份是如何执行的

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

9.1.3 Fork

• Fork的作用是复制一个与当前进程一样的进程，新进程的所有数据（变量、环境变量、程序计数器等）数值和原进程一致，但是也是一个全新的进程，并作为原进程的子进程。
• 在Linux程序中fork（）会产生一个和父进程完全相同的子进程，但子进程在此后会多次exec系统调用，出于效率考虑，Linux中引入了写时复制技术。
• 一般情况下父进程和子进程会共同用同一段物理内存，只有进程空间的各段内容要发生变化时，才会将父进程的内容复制一份给子进程。

10.Redis集群

10.1问题

容量不够，redis如何进行扩容

并发写操作，redis如何分摊

另外，主从模式，薪火相传模式，主机宕机，导致IP地址发生变化，应用程序中配置需要修改对应的主机地址，端口等信息。

之前通过代理主机实现，但是redis 3.0 中提供了解决方案。就是无中心化集群配置。

10.2 什么是集群

Redis集群实现了对redis的水平扩容，即启动N个redis节点，将整个数据库分布存储在这N个节点中，每个节点存储总数据的1/N