Redis单线程如何处理高并发

1.阻塞IO 与 非阻塞 IO

Java 在 JDK1.4 中引入 NIO，但是也有很多人在使用阻塞 IO，这两种 IO 有什么区别？

在阻塞模式下，如果你从数据流中读取不到指定大小的数据两，IO 就会阻塞。比如已知会有 10 个字节发送过来，但是我目前只收到 4 个，还剩六个，此时就会发生阻塞。如果是非阻塞模式，虽然此时只收到 4 个字节，但是读到 4 个字节就会立即返回，不会傻傻等着，等另外 6 个字节来的时候，再去继续读取。

所以阻塞 IO 性能低于 非阻塞 IO。

如果有一个 Web 服务器，使用阻塞 IO 来处理请求，那么每一个请求都需要开启一个新的线程；但是如果使用了非阻塞 IO，基本上一个小小线程池就够用了，因为不会发生阻塞，每一个线程都能够高效利用。

2.Redis 的线程模型

首先一点，Redis 是单线程。单线程如何解决高并发问题的？

实际上，能够处理高并发的单线程应用不仅仅是 Redis，除了 Redis 之外，还有 NodeJS、Nginx 等等也是单线程。

Redis 虽然是单线程，但是运行很快，主要有如下几方面原因：

1. Redis 中的所有数据都是基于内存的，所有的计算也都是内存级别的计算，所以快。
2. Redis 是单线程的，所以有一些时间复杂度高的指令，可能会导致 Redis 卡顿，例如 keys。
3. Redis 在处理并发的客户端连接时，使用了非阻塞 IO。
4. 在使用非阻塞 IO 时，有一个问题，就是线程如何知道剩下的数据来了？这里就涉及到一个新的概念叫做多路复用，本质上就是一个事件轮询 API。
5. Redis 会给每一个客户端指令通过队列来排队进行顺序处理，Redis 做出响应时，也会有一个响应的队列。

Redis的通信协议

Redis 通信使用了文本协议，文本协议比较费流量，但是 Redis 作者认为数据库的瓶颈不在于网络流量，而在于内部逻辑，所以采用了这样一个费流量的文本协议。

这个文本协议叫做 Redis Serialization Protocol，简称 RESP

Redis 协议将传输的数据结构分为 5 种最小单元，单元结束时，加上回车换行符 \r\n。

1. 单行字符串以 + 开始，例如 +javaboy.org\r\n
2. 多行字符串以 $ 开始，后面加上字符串长度，例如 $11\r\njavaboy.org\r\n
3. 整数值以: 开始，例如 :1024\r\n
4. 错误消息以 - 开始
5. 数组以 * 开始，后面加上数组长度

需要注意的是，如果是客户端连接服务端，只能使用第 5 种

1.准备工作

做两件事情：

为了方便客户端连接 Redis，我们关闭 Redis 种的保护模式(在 redis.conf 文件中)

protected-mode no

同时关闭密码：

# requirepass xxxx

配置完成后，重启Redis

2.实战

接下来，我们通过 Socket+RESP 来定义两个最最常见的命令 set 和 get

package org.taoguoguo.socket;

import java.io.IOException;
import java.net.Socket;

/**
 * @author taoguoguo
 * @description RedisClient
 * @website https://www.cnblogs.com/doondo
 * @create 2021-04-26 10:04
 */
public class RedisClient {

    private Socket socket;

    public RedisClient() {
        try {
            socket = new Socket("192.168.199.229",6379);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("Redis连接失败");
        }

    }

    /**
     * 执行 Redis 中的 set 命令 [set,key,value]
     * @param key
     * @param value
     * @return
     */
    public String set(String key, String value) throws IOException {
        StringBuilder sb = new StringBuilder();
        sb.append("*3")
                .append("\r\n")
                .append("$")
                .append("set".length())
                .append("\r\n")
                .append("set")
                .append("\r\n")
                .append("$")
                .append(key.getBytes().length)
                .append("\r\n")
                .append(key)
                .append("\r\n")
                .append("$")
                .append(value.getBytes().length)
                .append("\r\n")
                .append(value)
                .append("\r\n");
        socket.getOutputStream().write(sb.toString().getBytes());
        byte[] buf = new byte[1024];
        socket.getInputStream().read(buf);
        return new String(buf);
    }

    public String get(String key) throws IOException {
        StringBuilder sb = new StringBuilder();
        sb.append("*2")
                .append("\r\n")
                .append("$")
                .append("get".length())
                .append("\r\n")
                .append("get")
                .append("\r\n")
                .append("$")
                .append(key.getBytes().length)
                .append("\r\n")
                .append(key)
                .append("\r\n");
        socket.getOutputStream().write(sb.toString().getBytes());
        byte[] buf = new byte[1024];
        socket.getInputStream().read(buf);
        return new String(buf);


    }

    public static void main(String[] args) throws IOException {
        RedisClient redisClient = new RedisClient();
        redisClient.set("k1", "v1");
        String k1 = redisClient.get("k1");
        System.out.println("k1的值: " + k1);

    }
}

Redis持久化

Redis 是一个缓存工具，也叫做 NoSQL 数据库，既然是数据库，必然支持数据的持久化操作。在 Redis中，数据库持久化一共有两种方案：

1. 快照方式

   快照采用一次全量备份，快照采用内存数据二进制序列化的形式，在存储上非常的简促，非常省空间。

2. AOF 日志

   AOF日志是连续的增量备份，AOF记录内存修改的指定的记录文本，日志在长期的记录过程中会变得越来越大，所以数据库重启时，如果需要加载AOF日志进行指令重放，时间就会比较漫长，因为原理是通过日志把你曾经执行过的命令挨个再执行一遍，所以耗费时间长，所以一般我们需要定期对AOF日志进行重写瘦身。

1.RDB快照

1.1 原理

redis 是一个单线程程序，那这个程序要同时负责多个客户端的并发读写操作，还有内存数据的读写。这么多指令同时做是如何执行的呢？可能互相之间会有影响，Redis是如何实现的呢？

Redis 使用操作系统的多进程机制来实现快照持久化：Redis 在持久化时，会调用 glibc 函数 fork 一个子进程，然后将快照持久化操作完全交给子进程去处理，而父进程则继续处理客户端请求。在这个过程中，子进程能够看到的内存中的数据在子进程产生的一瞬间就固定下来了，再也不会改变，也就是为什么 Redis 持久化叫做 快照。

1.2 具体配置

在 Redis 中，默认情况下，快照持久化的方式就是开启的。

默认情况下会产生一个 dump.rdb 文件，这个文件就是备份下来的文件。当 Redis 启动时，会自动的去加载这个 rdb 文件，从该文件中恢复数据。如果删除这个文件，重启 redis，之前 dump.rdb 中持久化的数据就丢失了。

具体的配置，在 redis.conf 文件中

#快照频率 You can set these explicitly by uncommenting the three following lines
#900秒内至少有1个键被更改进行快照
 save 900 1
#300秒至少有10个键被更改进行快照
 save 300 100
#60秒内至少有10000个键被更改进行快照
 save 60 10000

#快照执行出错后，是否继续处理客户端的写命令
stop-writes-on-bgsave-error yes

# 是否对快照文件进行压缩
rdbcompression yes

# 表示生成的快照文件名
dbfilename dump.rdb

# 表示生成的快照文件位置
dir ./

1.3 备份流程

1. 在 Redis 运行过程中，我们可以向 Redis 发送一条 save 命令来创建一个快照。但是需要注意，save 是一个阻塞命令，Redis 在收到 save 命令开始处理备份操作之后，在处理完成之前，将不再处理其他的请求。其他命令会被挂起，所以 save 使用的并不多。
2. 我们一般可以使用 bgsave，bgsave 会 fork 一个子进程去处理备份的事情，不影响父进程处理客户端请求。
3. 我们定义的备份规则，如果有规则满足，也会自动触发 bgsave。
4. 另外，当我们执行 shutdown 命令时，也会触发 save 命令，备份工作完成后，Redis 才会关闭。
5. 用 Redis 搭建主从复制时，在 从机连上主机之后，会自动发送一条 sync 同步命令，主机收到命令之后，首先执行 bgsave 对数据进行快照，然后才会给从机发送快照数据进行同步。

2.AOF日志

与快照持久化不同，AOF 持久化是将被执行的命令追加到 aof 文件末尾，在恢复时，只需要把记录下来的命令从头到尾执行一遍即可。

默认情况下，AOF 是没有开启的。我们需要手动开启

# 开启 aof 配置
appendonly yes

# AOF 文件名
appendfilename "appendonly.aof"

# 备份的时机，下面的配置表示每秒钟备份一次
appendfsync everysec

# 表示 aof 文件在压缩时，是否还继续进行同步操作
no-appendfsync-on-rewrite no

# 表示当目前 aof 文件大小超过上一次重写时的 aof 文件大小的百分之多少的时候，再次进行重写
auto-aof-rewrite-percentage 100

# 如果之前没有重写过，则以启动时的 aof 大小为依据，同时要求 aof 文件至少要大于 64M
auto-aof-rewrite-min-size 64mb

同时为了避免快照备份的影响，记得将快照备份关闭：

save ""
#save 900 1
#save 300 10
#save 60 10000

手动重写AOF文件

BGREWRITEAOF
#在满足AOF规则时，会自动重写 BGREWRITEAOF 命令

3.如何选择哪种快照方式

在实际生产环境中，根据数据量、应用对数据的安全要求、预算限制和业务场景等不同情况，会有各种各样的持久化策略；

1. 如果 Redis 仅仅做缓存服务器，一般来说不必太过于太在乎两者数据，不是说做缓存一定不用这两者，可能也会用到
2. 如果同时两种持久化方式RDB快照和AOF日志都开启了，当Redis重启时会优先载入AOF的文件来恢复原始的数据，因为在通常情况下，AOF的文件保存的数据集要比RDB文件保存的数据集要完整，RDB数据不完整时，服务器重启也只会优先找AOF文件。
3. 那有小伙伴就疑惑了，那我直接用AOF得了。但 Redis 作者实际不推荐这种做法，因为RDB快照更适合用于备份数据库、快速重启等。
4. 同时由于RDB文件通常用于后备用途，所以一般在从机上做RDB文件备份，并且通常15分钟备份一次即可。
5. 使用AOF的好处是，最坏情况下也只会丢失大概一秒钟的数据，并且脚本简单，只需要load自己的AOF文件。但代价是带来了持续的IO，因为需要不停的去读写文件。AOF还有一个很大的劣势，就是在重写过程中产生的新数据和新文件，造成的阻塞几乎是不可避免的。所以如果硬盘许可时，应当尽量避免AOF的频率。应当结合设备性能和具体项目中的数据进行配置AOF文件大小，通常要设置几个G以上。
6. 使用Redis主从结构也可以实现高性能、高可用。

Redis事务

正常来说，一个可以商用的数据库往往都有比较完善的事务支持，Redis 当然也不例外。相对于 关系型数据库中的事务模型，Redis 中的事务要简单很多。因为简单，所以 Redis 中的事务模型不太严格，所以我们不能像使用关系型数据库中的事务那样来使用 Redis。

在关系型数据库中，和事务相关的三个指令分别是：

• begin 开启事务
• commit 提交事务
• rollback 事务回滚

在 Redis 中，当然也有对应的指令：

• multi 开启事务
• exec 执行事务
• discard 放弃事务

1.原子性

Redis 中的事务并不能算作原子性。它仅仅具备隔离性，也就是说当前的事务可以不被其他事务打断

由于每一次事务操作涉及到的指令还是比较多的，为了提高执行效率，我们在使用客户端的时候，可以通过 pipeline 来优化指令的执行。

Redis 中还有一个 watch 指令，watch 可以用来监控一个 key，通过这种监控，我们可以确保在 exec之前，watch 的键的没有被修改过。相当于乐观锁，A用户操作这个键时，B用户不可修改该键，否则事务提交失败。

操作示例：

127.0.0.1:6379> FLUSHALL
OK
127.0.0.1:6379> clear
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)> incr k1 
QUEUED
127.0.0.1:6379(TX)> set k3 v3 
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) OK
3) (error) ERR value is not an integer or out of range
4) OK
127.0.0.1:6379> keys * 
1) "k2"
2) "k3"
3) "k1"
127.0.0.1:6379> get k1 
"v1"
127.0.0.1:6379> get k2
"v2"
127.0.0.1:6379> get k3
"v3"
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> DISCARD
OK
127.0.0.1:6379> keys * 
1) "k2"
2) "k3"
3) "k1"
127.0.0.1:6379> 

2.Java 实现

package trans;

import org.taoguoguo.redis.Redis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

import java.util.List;

/**
 * @author taoguoguo
 * @description RedisTransaction
 * @website https://www.cnblogs.com/doondo
 * @create 2021-04-26 14:59
 */
public class RedisTransaction {
    public static void main(String[] args) {
        new Redis().execute(jedis -> {
            new RedisTransaction().saveMoney(jedis, "taoguoguo", 1000);
        });
    }

    public Integer saveMoney(Jedis jedis, String userId, Integer money) {
        while (true) {
            jedis.watch(userId);
            int v = Integer.parseInt(jedis.get(userId)) + money;
            Transaction tx = jedis.multi();
            tx.set(userId, String.valueOf(v));
            List