分布式框架-Redis 03 主从架构

t二师兄
215 阅读8分钟

1 概述

Redis的多机数据库实现，主要有三种方式：

  1. Redis主从复制
  2. Redis哨兵模式
  3. Redis集群模式

本文主要讲解一下Redis主从复制，主从的基本原理，以及Redis使用示例，其中包括管道和Redis lua脚本的使用

2 Redis主从架构

2.1 主从架构搭建

从搭建好的Redis中copy一份到其他服务器，修改相应的redis.conf，主要修改以下几个地方：

port 6380				//端口
pidfile /var/run/redis_6380.pid		//把pid进程号写入pidfile配置的文件
logfile "redis_6380.log"		//日志文件
dir /usr/local/redis/data/6380		//备份数据存放目录

# 需要注释掉的
# bind 127.0.0.1 			//bind绑定的是自己机器网卡的ip，如果有多块网卡可以配多个ip，代表允许客户端通过机器的哪些网卡ip去访问，内网一般可以不配置bind，注释掉即可

# 重点配置
# replicaof <masterip> <masterport> 
replicaof 192.168.1.188 6379		//从此处的redis复制数据
replica‐read‐only yes			//配置从节点只读

如此之后就搭建好了一个Redis主从架构，从此主节点的数据会同步到从节点进行备份

注意：从节点都设置成只读，写命令全部用主节点执行

2.2 主从架构原理

2.2.1 全量数据复制

简单解释一下：
如果你为master配置了一个slave，不管这个slave是否是第一次连接上master，都会发送一个psync命令给master请求复制数据，master接受到该命令后，会在自己的后台进行数据持久化通过bgsave生成最新的rdb快照文件（持久化期间，master会继续接受客户端的请求，它会把这些可能修改的数据集的请求缓存在内存中，redis.conf配置中有个repl-backlog-size 1mb），当持久化完成后会master会将这份最新的rdb数据发送给slave，slave会把接收到的数据进行持久化生成rdb，然后再加载到内存中，然后，master再将之前缓存在内存中的命令发送给slave，实现全量备份。

注：当master与slave之间的连接由于某些原因而断开时，slave能够自动重连master，如果master收到了多个slave并发连接请求，它只会进行一次性持久化，而不是一个连接持久化一次，然后再把这一份持久化数据发送给多个并发连接的slave。

2.2.2 部分数据复制（断点续传）

简单解释一下：
Redis2.8版本以后，可以支持部分数据复制psync去master同步数据，slave和master都维护了复制的数据的下标offset和master的进程id，因此，当网络中断重连后，slave会请求master继续进行未完成的复制，从所记录的offset开始，如果master进程id变化了，或者从节点数据下标offset太旧，已经不在master的缓存队列里了，那么就会进行一次全量复制。

2.2.3 主从复制风暴

如果有非常多从节点，多个从节点同时从主节点复制数据会导致主节点压力非常大，这就会造成主从复制风暴，为了缓解这种现象，可以将从节点跟从节点进行数据复制，采用从节点树形结构。具体做法，就是下面的ip改为从节点即可：

replicaof 192.168.1.188 6379

2.3 Redis使用示例

引入Jedis依赖

<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>2.9.0</version>
</dependency>

2.3.1 基本示例

public class JedisTest {

    public static void main(String[] args) {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(10);
        jedisPoolConfig.setMaxTotal(20);
        jedisPoolConfig.setMinIdle(5);

        JedisPool jedisPool = new JedisPool(jedisPoolConfig, "8.129.48.169", 6379, 3000, null);

        Jedis jedis = null;

        try {
            jedis = jedisPool.getResource();

            System.out.println(jedis.set("hello", "hello redis"));
            System.out.println(jedis.get("hello"));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //注意这里不是关闭连接，在JedisPool模式下，Jedis会被归还给资源池。
            if (jedis != null) {
                jedis.close();
            }
        }
    }

}

2.3.2 管道示例

public class JedisTest2 {

    public static void main(String[] args) {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMinIdle(5);
        jedisPoolConfig.setMaxTotal(20);
        jedisPoolConfig.setMaxIdle(10);

        JedisPool jedisPool = new JedisPool(jedisPoolConfig, "8.129.48.169", 6379, 3000, null);

        Jedis jedis = null;

        try {
            jedis = jedisPool.getResource();

            //管道示例
            //管道的命令执行方式：cat redis.txt | redis-cli -h 8.129.48.169 -a password -p 6379 --pipe
            Pipeline pipeline = jedis.pipelined();
            for (int i = 0; i < 5; i++){
                pipeline.incr("pipelineKey");
                pipeline.set("hello" + i, "hello redis");
                
                //模拟一下管道报错
                //pipeline.setbit("hello", -1, true);
            }
            List<Object> results = pipeline.syncAndReturnAll();
            System.out.println(results);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //注意这里不是关闭连接，在JedisPool模式下，Jedis会被归还给资源池。
            if (jedis != null) {
                jedis.close();
            }
        }
    }

}

客户端可以一次性发送多个请求而不用等待服务器的响应，待所有命令都发送完后再一次性读取服务的响应，这样可以极大的降低多条命令执行的网络传输开销，管道执行多条命令的网络开销实际上只相当于一次命令执行的网络开销。需要注意到是用pipeline方式打包命令发送，redis必须在处理完所有命令前先缓存起所有命令的处理结果。打包的命令越多，缓存消耗内存也越多。所以并不是打包的命令越多越好。pipeline中发送的每个command都会被server立即执行，如果执行失败，将会在此后的响应中得到信息；也就是pipeline并不是表达“所有command都一起成功”的语义，管道中前面命令失败，后面命令不会有影响，继续执行，比如模拟一下管道报错：

 //模拟一下管道报错
 pipeline.setbit("hello", -1, true);

2.3.3 Redis Lua Script示例

Redis在2.6推出了脚本功能，允许开发者使用Lua语言编写脚本传到Redis中执行，使用脚本的好处如下：

  1. 减少网络开销：假如本来5次网络请求的操作，可以用一个请求完成。原先5次请求的逻辑放在redis服务器上完成。使用脚本，减少了网络往返时延，这点跟管道类似。
  2. 原子操作：Redis会将整个脚本作为一个整体执行，中间不会被其他命令插入，管道不是原子的，不过redis的批量操作命令（类似mset）是原子的。
  3. 替代redis的事务功能：redis自带的事务功能很鸡肋，报错不支持回滚，而redis的lua脚本几乎实现了常规的事务功能，支持报错事务回滚，官方推荐如果要用redis事务功能可以用redis lua脚本替换。 官网提示
A Redis script is transactional by definition, so everything you can do with a Redis t
ransaction, you can also do with a script,
and usually the script will be both simpler and faster.

代码示例：

public class JedisTestLua {

    public static void main(String[] args) {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMinIdle(5);
        jedisPoolConfig.setMaxTotal(20);
        jedisPoolConfig.setMaxIdle(10);

        JedisPool jedisPool = new JedisPool(jedisPoolConfig, "127.0.0.1", 6379, 3000, null);

        Jedis jedis = null;

        try {
            jedis = jedisPool.getResource();

            //lua脚本模拟一个商品减库存的原子操作
            //lua脚本执行方式：redis-cli --eval /tmp/test.lua
            jedis.set("product_count_10086", "15");
            String script = " local count = redis.call('get', KEYS[1]) " +
                    " local a = tonumber(count) " +
                    " local b = tonumber(ARGV[1]) " +
                    " if a >= b then " +
                    " redis.call('set', KEYS[1], a-b) " +
                    " return 1 " +
                    " end " +
                    " return 0 ";
            Object obj = jedis.eval(script, Arrays.asList("product_count_10086"), Arrays.asList("10"));
            System.out.println(obj);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //注意这里不是关闭连接，在JedisPool模式下，Jedis会被归还给资源池。
            if (jedis != null) {
                jedis.close();
            }
        }
    }

}

从Redis2.6.0版本开始，通过内置的Lua解释器，可以使用EVAL命令对Lua脚本进行求值。EVAL命令的格式如下：

EVAL script numkeys key [key ...] arg [arg ...]

script参数是一段Lua脚本程序，它会被运行在Redis服务器上下文中，这段脚本不必(也不应该)定义为一个Lua函数。numkeys参数用于指定键名参数的个数。键名参数 key [key ...] 从EVAL的第三个参数开始算起，表示在脚本中所用到的那些Redis键(key)，这些键名参数可以在 Lua中通过全局变量KEYS数组，用1为基址的形式访问( KEYS[1] ， KEYS[2] ，以此类推)。 在命令的最后，那些不是键名参数的附加参数 arg [arg ...] ，可以在Lua中通过全局变量ARGV数组访问，访问的形式和KEYS变量类似( ARGV[1] 、 ARGV[2] ，诸如此类)。例如

127.0.0.1:6379> eval "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 first second
1) "key1"
2) "key2"
3) "first"
4) "second"

其中 "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 是被求值的Lua脚本，数字2指定了键名参数的数量， key1和key2是键名参数，分别使用 KEYS[1] 和 KEYS[2] 访问，而最后的 first 和 second 则是附加参数，可以通过 ARGV[1] 和 ARGV[2] 访问它们。 在 Lua 脚本中，可以使用redis.call()函数来执行Redis命令，Jedis调用示例详见上面jedis连接示例：

jedis.set("product_stock_10016", "15"); //初始化商品10016的库存
String script = " local count = redis.call('get', KEYS[1]) " +
" local a = tonumber(count) " +
" local b = tonumber(ARGV[1]) " +
" if a >= b then " +
" redis.call('set', KEYS[1], a‐b) " +
//模拟语法报错回滚操作" bb == 0 " +
return 1 " +
" end " +
" return 0 ";
Object obj = jedis.eval(script, Arrays.asList("product_stock_10016"), Arrays.asList("10"));
System.out.println(obj);

注意，不要在Lua脚本中出现死循环和耗时的运算，否则redis会阻塞，将不接受其他的命令， 所以使用时要注意不能出现死循环、耗时的运算。redis是单进程、单线程执行脚本。管道不会阻塞redis。

avatar
文章
阅读
粉丝