目录
1、Redis基础
1.1 Redis是啥？能干啥？
是啥： Redis是一个开源的，基于内存亦可持久化的日志型、高性能Key-Value数据库，并提供多种语言的API
干啥： 性能极高 – Redis官方描述理论上能达到读的速度是110000次/s,写的速度是81000次/s 。可以使用redis-benchmark命令测试：
- [root@ydt1 bin]# ./redis-benchmark -n 100000 -q script load "redis.call('set','foo','bar')"
- script load redis.call('set','foo','bar'): 69541.03 requests per second
-
- [root@ydt1 bin]# ./redis-benchmark -n 100000 -q script load "redis.call('get','foo')"
- script load redis.call('get','foo'): 83125.52 requests per second
-
- #可以通过sysbench对比下MySQL的QPS
- #安装sysbench压测工具
- yum install gcc gcc-c++ autoconf automake make libtool bzr mysql-devel git
- git clone https://github.com/akopytov/sysbench.git
- cd sysbench
- git checkout 1.0.18
- ./autogen.sh
- ./configure --prefix=/usr --mandir=/usr/share/man
- make && make install
-
- #步骤一：准备数据
- sysbench --db-driver=mysql --mysql-host=192.168.223.128 --mysql-port=3306 --mysql-user=root --mysql-password=root --mysql-db=sbtest --table_size=10000 --tables=1 --events=0 --time=10 --threads=2 oltp_read_only prepare
-
- #只读场景压测
- #步骤二：运行workload
- sysbench --db-driver=mysql --mysql-host=192.168.223.128 --mysql-port=3306 --mysql-user=root --mysql-password=root --mysql-db=sbtest --table_size=10000 --tables=1 --events=0 --time=10 --threads=2 --percentile=95 --skip-trx=1 --report-interval=1 oltp_read_only run
-
- #只写场景压测
- #步骤二：运行workload
- sysbench --db-driver=mysql --mysql-host=192.168.223.128 --mysql-port=3306 --mysql-user=root --mysql-password=root --mysql-db=sbtest --table_size=10000 --tables=1 --events=0 --time=10 --threads=2 --percentile=95 --report-interval=1 oltp_write_only run
-
- #步骤三：清理数据
- sysbench --db-driver=mysql --mysql-host=192.168.223.128 --mysql-port=3306 --mysql-user=root --mysql-password=root --mysql-db=sbtest --table_size=10000 --tables=1 --events=0 --time=10 --threads=2 --percentile=95 oltp_write_only cleanup
-
- #SysBench参数说明
- #db-driver 数据库引擎。
- #mysql-host RDS实例连接地址。
- #mysql-port RDS实例连接端口。
- #mysql-user RDS实例账号。
- #mysql-password RDS实例账号对应的密码。
- #mysql-db RDS实例数据库名。
- #table_size 测试表大小。
- #tables 测试表数量。
- #events 测试请求数量。
- #time 测试时间。
- #threads 测试线程数。
- #percentile 需要统计的百分比，默认值为95%，即请求在95%的情况下的执行时间。
- #report-interval 表示N秒输出一次测试进度报告，0表示关闭测试进度报告输出，仅输出最终的报告结果。
- #skip-trx 是否跳过事务。
- #1：跳过
- #0：不跳过
丰富的数据类型 – Redis支持二进制的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。 原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来，实际生产中也可以通过集成API使用LUA脚本进行操作。 丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。
1.2 安装Redis
- #第一步：下载redis安装包 官网：https://redis.io/
- wget http://download.redis.io/releases/redis-4.0.6.tar.gz
-
- #第二步：解压压缩包
- tar -zxvf redis-4.0.6.tar.gz
-
- #第三步：yum安装gcc依赖
- yum install gcc
-
- #第四步：跳转到redis解压目录下
- cd redis-4.0.6
-
- #第五步：编译安装
- make MALLOC=libc
- #将bin目录安装到当前目录下，当然，你也可以直接使用src下的脚本
- make install PREFIX=/usr/local/redis-4.0.6
启动服务端：
List(列表)---有序
- @Test
- public void insertList() {
- jedis.del("person");
- jedis.del("city");
- //左压栈laohe, laoli, laowang
- jedis.lpush("person", "laowang", "laoli", "laohe");
- //右压栈changsha, shenzhen, guangzhou
- jedis.rpush("city", "changsha", "shenzhen", "guangzhou");//右压栈"guangzhou","shenzhen","changsha"
-
- System.out.println(jedis.lpop("person"));//左弹栈
- System.out.println(jedis.rpop("city"));//右弹栈
-
- System.out.println(jedis.lrange("person", 0, -1));//先进后出
- System.out.println(jedis.lrange("city", 0, -1));//先进先出
- }
输出结果：
- laohe
- guangzhou
- [laoli, laowang]
- [changsha, shenzhen]
Set(集合)---无序，差值
- /**
- * Set (无序)
- */
- @Test
- public void insertSet() {
- jedis.del("username","password");
- jedis.sadd("username", "laozhang", "laoxie", "laojiang");
- jedis.sadd("password", "laohu", "laoxie", "laojiang");
- System.out.println(jedis.smembers("username"));//取列表值
- System.out.println(jedis.sdiff("username", "password"));//取差值
- }
输出结果：
ZSet(sorted set：有序集合)--- 排行榜
- /**
- * 有序Set
- */
- @Test
- public void insertZSet() {
- jedis.del("tuhao");
- jedis.zadd("tuhao", 1000, "mayun");
- jedis.zadd("tuhao", 1, "wangjianlin");
- jedis.zadd("tuhao", 100, "mahuateng");
- System.out.println(jedis.zrange("tuhao", 0, -1));//屌丝榜
- System.out.println(jedis.zrevrange("tuhao", 0, -1));//土豪榜
- }
输出：
- [wangjianlin, mahuateng, mayun]
- [mayun, mahuateng, wangjianlin]
2、分布式锁解决方案-Redis（略）
需要的了解的同学移步至：分布式锁解决方案实战_长沙老码农-CSDN博客
3、Redis性能调优军规
尽管Redis是一个非常快速的内存数据存储媒介，也并不代表Redis不会产生性能问题，我这里总结了一些处理性能问题的手段！
3.1 缩短键值对的存储长度
键值对的长度是和性能成反比的 ， 在 key 不变的情况下，value 值越大操作效率越慢
- Logger logger = Logger.getLogger(ClusterTest.class);
- JedisPool jedisPool = (JedisPool) context.getBean("jedisPool");
- Jedis jedis = jedisPool.getResource();
- Pipeline pipe = jedis.pipelined(); // 先创建一个 pipeline 的链接对象
- long start = System.currentTimeMillis();
- for (int i = 0; i < 100000; i++) {
- pipe.set(String.valueOf(i), String.valueOf(i));
- }
- pipe.sync();
- long end = System.currentTimeMillis();
- logger.info("the general total time is:" + (end - start));
-
- String v = "aaasssssssssssssssssdakldwndonqwdknaknwndddddoooooaddasssssssssssssssssssssssssssaaasssssssssssssssssdakldwndonqwdknaknwndddddoooooaddasssssssssssssssssssssssssssaaasssssssssssssssssdakldwndonqwdknaknwndddddoooooaddasssssssssssssssssssssssssssaaasssssssssssssssssdakldwndonqwdknaknwndddddoooooaddasssssssssssssssssssssssssssaaasssssssssssssssssdakldwndonqwdknaknwndddddoooooaddasssssssssssssssssssssssssssaaasssssssssssssssssdakldwndonqwdknaknwndddddoooooaddasssssssssssssssssssssssssssaaasssssssssssssssssdakldwndonqwdknaknwndddddoooooaddasssssssssssssssssssssssssssaaasssssssssssssssssdakldwndonqwdknaknwndddddoooooaddasssssssssssssssssssssssssssaaasssssssssssssssssdakldwndonqwdknaknwndddddoooooa";
- System.out.println(v.getBytes().length);
-
- start = System.currentTimeMillis();
- for (int i = 0; i < 100000; i++) {
- pipe.set(String.valueOf(i), v + String.valueOf(i));
- }
- pipe.sync();
- end = System.currentTimeMillis();
- logger.info("the general total time is:" + (end - start));
-
- #执行结果如下：
- #17:32:17,155 INFO ClusterTest:227 - the general total time is:498
- #699
- #17:32:19,820 INFO ClusterTest:238 - the general total time is:2656
3.2 使用 lazy free（延迟删除）特性
lazy free 特性是 Redis 4.0 新增的一个非常实用的功能，它可以理解为惰性删除或延迟删除。意思是在删除的时候提供异步延时释放键值的功能，把键值释放操作放在 BIO(Background I/O) 单独的子线程处理中，以减少删除对 Redis 主线程的阻塞，可以有效地避免删除 big key 时带来的性能和可用性问题。
lazy free 对应了 4 种场景，默认都是关闭的：
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
slave-lazy-flush no
它们代表的含义如下：
-
lazyfree-lazy-eviction：表示当 Redis 运行内存超过 maxmeory 时，是否开启 lazy free 机制删除；
-
lazyfree-lazy-expire：表示设置了过期时间的键值，当过期之后是否开启 lazy free 机制删除；
-
lazyfree-lazy-server-del：有些指令在处理已存在的键时，会带有一个隐式的 del 键的操作，比如 rename 命令，当目标键已存在，Redis 会先删除目标键，如果这些目标键是一个 big key，就会造成阻塞删除的问题，此配置表示在这种场景中是否开启 lazy free 机制删除；
-
slave-lazy-flush：针对 slave(从节点) 进行全量数据同步，slave 在加载 master 的 RDB 文件前，会运行 flushall 来清理自己的数据，它表示此时是否开启 lazy free 机制删除。
建议开启其中的 lazyfree-lazy-eviction、lazyfree-lazy-expire、lazyfree-lazy-server-del 等配置，这样就可以有效的提高主线程的执行效率。
3.3 设置键值的过期时间
我们应该根据实际的业务情况，对键值设置合理的过期时间，这样 Redis 会帮你自动清除过期的键值对，以节约对内存的占用，以避免键值过多的堆积，频繁的触发内存淘汰策略。
3.4 禁用长耗时的查询命令
以从以下几个方面入手改造：
-
决定禁止使用 keys 命令；
-
尽可能将排序、并集、交集等操作放在客户端执行，以减少 Redis 服务器运行压力；
3.5 使用 slowlog 优化耗时命令
我们可以使用 slowlog 功能找出最耗时的 Redis 命令进行相关的优化，以提升 Redis 的运行速度，慢查询有两个重要的配置项：
-
slowlog-log-slower-than ：用于设置慢查询的评定时间，也就是说超过此配置项的命令，将会被当成慢操作记录在慢查询日志中，它执行单位是微秒 (1 秒等于 1000000 微秒)；
-
slowlog-max-len ：用来配置慢查询日志的最大记录数。
我们可以根据实际的业务情况进行相应的配置，其中慢日志是按照插入的顺序倒序存入慢查询日志中，我们可以使用 slowlog get 来获取相关的慢查询日志，再找到这些慢查询对应的业务进行相关的优化。
- redis> SLOWLOG GET
- 1) 1) (integer) 12 # 唯一性(unique)的日志标识符
- 2) (integer) 1324097834 # 被记录命令的执行时间点，以 UNIX 时间戳格式表示
- 3) (integer) 1689 # 查询执行时间，以微秒为单位
- 4) 1) "SET" # 执行的命令
- 2) "1"
- 3) "LAOHU"
- 4) "slowlog-log-slower-than"
3.6 使用 Pipeline 批量操作数据
Pipeline (管道技术) 是客户端提供的一种批处理技术，用于一次处理多个 Redis 命令，从而提高整个交互的性能。
- @Test
- public void testGeneralAndPipeline(){
- JedisPool jedisPool = (JedisPool) context.getBean("jedisPool");
- Jedis jedis = jedisPool.getResource();
- Logger logger = Logger.getLogger(ClusterTest.class);
- long start = System.currentTimeMillis();
- for (int i = 0; i < 10000; i++) {
- jedis.set(String.valueOf(i), String.valueOf(i));
- }
- long end = System.currentTimeMillis();
- logger.info("the general total time is:" + (end - start));
-
- Pipeline pipe = jedis.pipelined(); // 先创建一个 pipeline 的链接对象
- long start_pipe = System.currentTimeMillis();
- for (int i = 0; i < 10000; i++) {
- pipe.set(String.valueOf(i), String.valueOf(i));
- }
- pipe.sync(); // 获取所有的 response
- long end_pipe = System.currentTimeMillis();
- logger.info("the pipe total time is:" + (end_pipe - start_pipe));
- }
执行结果：
- 16:03:17,592 INFO ClusterTest:114 - the general total time is:2634
- 16:03:17,692 INFO ClusterTest:123 - the pipe total time is:77
3.7 避免大量数据同时失效
不仅仅会造成缓存雪崩，数据库服务器承压太大而宕机，对于Redis本身来说，瞬间需要干掉大量的key，也是对cpu性能的一个考验！
hz 10---》每秒执行10次过期扫描
解读：每次从过期字典（所有设置了过期时间键值对的集合）中随机获取20个，如果过期键值对超过四分之一，那么会继续从字典中获取20个继续删除过期键值对，如此循环往复，会造成大量的CPU损耗，并且在整个执行过程会导致 Redis 的读写出现明显的卡顿，卡顿的原因是内存管理器需要频繁回收内存页
3.8 客户端使用优化
在客户端的使用上我们除了要尽量使用 Pipeline 的技术外，还需要注意要尽量使用 Redis 连接池，而不是频繁创建销毁 Redis 连接，这样就可以减少网络传输次数和减少了非必要调用指令。
3.9 Redis内存管理与数据淘汰机制
最大内存设置
默认情况下，在32位OS中，Redis最大使用3GB的内存，在64位OS中则没有限制。
在使用Redis时，应该对数据占用的最大空间有一个基本准确的预估，并为Redis设定最大使用的内存。
否则在64位OS中Redis会无限制地占用内存（当物理内存被占满后会使用swap空间--硬盘内存中的一部分空间），容易引发各种各样的问题。
通过如下配置控制Redis使用的最大内存：
maxmemory 100mb 在内存占用达到了maxmemory后，再向Redis写入数据时，Redis会：
-
根据配置的数据淘汰策略尝试淘汰数据，释放空间
-
如果没有数据可以淘汰，或者没有配置数据淘汰策略，那么Redis会对所有写请求返回错误，但读请求仍然可以正常执行
- @Test
- public void testMaxmemory(){
- JedisPool jedisPool = (JedisPool) context.getBean("jedisPool");
- Jedis jedis = jedisPool.getResource();
- Transaction transaction = jedis.multi();
- for (int i = 0; i < 100000; i++) {
- transaction.set("" + i,"value is " + i);
- }
- transaction.exec();
- }
异常信息：io.lettuce.core.RedisCommandExecutionException: OOM command not allowed when used memory > 'maxmemory'.
在为Redis设置maxmemory时，需要注意：
如果采用了Redis的主从同步，主节点向从节点同步数据时，会占用掉一部分内存空间
如果maxmemory过于接近主机的可用内存，会导致数据同步时内存不足。
所以设置的maxmemory不要过于接近主机可用的内存，留出一部分预留用作主从同步。
数据淘汰机制
Redis提供了5种数据淘汰策略：
-
volatile-lru：使用LRU算法进行数据淘汰（淘汰上次使用时间最早的，且使用次数最少的key），只淘汰设定了有效期的key
-
allkeys-lru：使用LRU算法进行数据淘汰，所有的key都可以被淘汰
-
volatile-random：随机淘汰数据，只淘汰设定了有效期的key
-
allkeys-random：随机淘汰数据，所有的key都可以被淘汰
-
volatile-ttl：淘汰剩余有效期最短的key
最好为Redis指定一种有效的数据淘汰策略以配合maxmemory设置，避免在内存使用满后发生写入失败的情况。
一般来说，推荐使用的策略是volatile-lru，并辨识Redis中保存的数据的重要性。
对于那些重要的，绝对不能丢弃的数据（如配置类数据等），应不设置有效期，这样Redis就永远不会淘汰这些数据。
对于那些相对不是那么重要的，并且能够热加载的数据（比如缓存最近登录的用户信息，当在Redis中找不到时，程序会去DB中读取），可以设置上有效期，这样在内存不够时Redis就会淘汰这部分数据。
配置方法：
maxmemory-policy volatile-lru #默认是noeviction，即不进行数据淘汰
3.10 使用物理机而非虚拟机安装 Redis 服务
在虚拟机中运行 Redis 服务器，因为和物理机共享一个物理网口，并且一台物理机可能有多个虚拟机在运行，因此在内存占用上和网络延迟方面都会有很糟糕的表现，我们可以通过 ./redis-cli --intrinsic-latency 100 命令查看延迟时间，如果对 Redis 的性能有较高要求的话，应尽可能在物理机上直接部署 Redis 服务器。
- [root@ydt src]# ./redis-cli --intrinsic-latency 100
- Max latency so far: 1 microseconds.
- Max latency so far: 7 microseconds.
- Max latency so far: 9 microseconds.
- Max latency so far: 29 microseconds.
- Max latency so far: 399 microseconds.
- Max latency so far: 1243 microseconds.
- Max latency so far: 2157 microseconds.
- Max latency so far: 3847 microseconds.
- Max latency so far: 3980 microseconds.
- Max latency so far: 5076 microseconds.
- Max latency so far: 23236 microseconds.
- Max latency so far: 31935 microseconds.
- Max latency so far: 46829 microseconds.
-
- 1838316588 total runs (avg latency: 0.0544 microseconds / 54.40 nanoseconds per run).
- Worst run took 860865x longer than the average latency.
-
- #注意：后面的参数100表示100s
- #由测试结果可以看出来，redis内部延迟最大为46829微秒(46毫秒)，这会是一个不太好的消息，因为内部延迟超过100微秒性能就不是很好了，最主要的原因是系统有其他应#用在共享cpu
3.11 检查数据持久化策略
Redis 的持久化策略是将内存数据复制到硬盘上，这样才可以进行容灾恢复或者数据迁移，但维护此持久化的功能，需要很大的性能开销。
在 Redis 4.0 之后，Redis 有 3 种持久化的方式：
-
RDB（Redis DataBase，快照方式）将某一个时刻的内存数据，以二进制的方式写入磁盘；
-
AOF（Append Only File，文件追加方式），记录所有的操作命令，并以文本的形式追加到文件中；
-
混合持久化方式，Redis 4.0 之后新增的方式，混合持久化是结合了 RDB 和 AOF 的优点，在写入的时候，先把当前的数据以 RDB 的形式写入文件的开头，再将后续的操作命令以 AOF 的格式存入文件，这样既能保证 Redis 重启时的速度，又能减低数据丢失的风险。
RDB 和 AOF 持久化各有利弊，RDB 可能会导致一定时间内的数据丢失，而 AOF 由于文件较大则会影响 Redis 的启动速度，为了能同时拥有 RDB 和 AOF 的优点，Redis 4.0 之后新增了混合持久化的方式，因此我们在必须要进行持久化操作时，应该选择混合持久化的方式。
- appendonly yes #开启aof持久化，rbd是默认开启的
- appendfilename "appendonly.aof" #aof持久化文件
-
- aof-use-rdb-preamble yes #开启aof和rdb混合持久化模式
3.12 禁用 THP 特性
Linux kernel 在 2.6.38 内核增加了 Transparent Huge Pages (THP) 特性 ，支持大内存页 2MB 分配，默认开启。
这个特性实际上就是会把这种巨页的使用对用户透明，用户不需要再进行巨页的配置，内存会自动将连续的512个普通页作为一个巨页处理，为了减少维护人员配置巨页的工作
我们Redis在启动的时候也会去检查是否也已经禁用THP特性：
30663:M 25 Jul 18:34:48.221 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.
当开启了 THP 时，fork 的速度会变慢，fork 之后每个内存页从原来 4KB 变为 2MB，会大幅增加重写期间父进程内存消耗。同时每次写命令引起的复制内存页单位放大了 512 倍，会拖慢写操作的执行时间，导致大量写操作慢查询。例如简单的 incr 命令也会出现在慢查询中，因此 Redis 建议将此特性进行禁用，禁用方法命令如下：
echo never > /sys/kernel/mm/transparent_hugepage/enabled
为了使机器重启后 THP 配置依然生效，可以在 /etc/rc.local 中追加
echo never > /sys/kernel/mm/transparent_hugepage/enabled
3.13 使用分布式架构来增加读写速度
Redis 分布式架构有三个重要的手段：
-
主从同步
-
哨兵模式
-
Redis Cluster 集群
使用主从同步功能我们可以把写入放到主库上执行，把读功能转移到从服务上，因此就可以在单位时间内处理更多的请求，从而提升的 Redis 整体的运行速度。
而哨兵模式是对于主从功能的升级，但当主节点奔溃之后，无需人工干预就能自动恢复 Redis 的正常使用。
Redis Cluster 是 Redis 3.0 正式推出的，Redis 集群是通过将数据库分散存储到多个节点上来平衡各个节点的负载压力。
Redis Cluster 采用虚拟哈希槽分区，所有的键根据哈希函数映射到 0 ~ 16383 整数槽内，计算公式：slot = CRC16(key) & 16383，每一个节点负责维护一部分槽以及槽所映射的键值数据。这样 Redis 就可以把读写压力从一台服务器，分散给多台服务器了，因此性能会有很大的提升。
在这三个功能中，我们只需要使用一个就行了，毫无疑问 Redis Cluster 应该是首选的实现方案，它可以把读写压力自动的分担给更多的服务器，并且拥有自动容灾的能力。