3.Redis高级特性和应用（慢查询、Pipeline、事务、Lua、限流原理）

已于 2024-09-01 12:49:04 修改
阅读量666 收藏 8
点赞数 19
文章标签： redis
于 2024-09-01 12:38:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51052174/article/details/141782694
版权

1. Redis的慢查询

1.1 概念

在数据库系统中，慢查询是指执行时间超过预设阈值的查询操作。Redis也提供了慢查询日志功能，帮助开发和运维人员定位性能瓶颈。慢查询日志记录了执行时间较长的命令，以便进行优化。

1.2 慢查询的执行过程

Redis客户端执行一条命令的过程分为四个步骤：

  1. 发送命令：客户端向Redis服务器发送命令。
  2. 命令排队：命令在服务器中排队等待执行。
  3. 命令执行：Redis执行命令并记录执行时间。
  4. 返回结果：将结果返回给客户端。

需要注意，慢查询只统计步骤3的时间，因此可能存在网络问题或命令排队导致的超时，但这些不会被记录为慢查询。

1.3 生活场景示例

想象一下，你在餐馆点了菜。你下单（发送命令），然后服务员把订单放到厨房（命令排队），接着厨师开始做菜（命令执行），最后服务员把菜端到你面前（返回结果）。如果厨师做菜太慢，导致你等得不耐烦，这就类似于Redis的慢查询。

1.4 慢查询配置

Redis提供了两种方式来配置慢查询：

1.4.1 动态设置

使用命令动态修改慢查询阈值：

CONFIG SET slowlog-log-slower-than 20000
  • 默认阈值是10毫秒（10,000微秒）。
  • 设置为0表示记录所有命令，设置为负值表示不记录任何命令。
1.4.2 配置文件设置

在 redis.conf 配置文件中，可以找到以下配置项：

slowlog-max-len 128
  • slowlog-max-len 用于设置慢查询日志的最大条数，默认是128条。

1.5 慢查询操作命令

  • 获取慢查询日志：
SLOWLOG GET [n]
  • 获取慢查询日志长度：
SLOWLOG LEN
  • 重置慢查询日志：
SLOWLOG RESET

1.6 慢查询建议

  • 增加慢查询日志条数：建议设置为1000条以上，以避免丢失重要日志。
  • 调整阈值：根据Redis的并发量调整慢查询阈值，通常设置为1毫秒或更低，以便及时发现性能问题。

2. Pipeline

2.1 概念

Pipeline（流水线）是一种优化技术，可以将多条命令打包在一起，通过一次网络往返（RTT）发送给Redis服务器，从而减少网络延迟，提高执行效率。

2.2 生活场景示例

想象一下，你在超市购物。如果每次都要排队结账（发送命令），你可能会等得很久。但是如果你把所有商品放在购物车里，一次性结账（使用Pipeline），那么你就可以节省很多时间。

2.3 工作原理

在没有Pipeline的情况下，执行n条命令需要n次RTT，而使用Pipeline后，只需一次RTT即可完成所有命令的发送和接收。

2.4 使用场景

  • 执行大量命令时，使用Pipeline可以显著提高性能，尤其是在高延迟网络环境中。

2.5 注意事项

  • 发送的命令数量不宜过多，以免造成网络阻塞和客户端等待时间增加。
  • Pipeline只能操作一个Redis实例，适合批量操作。

2.6 Java代码示例

以下是使用Java的Jedis库实现Pipeline的代码示例：

java

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;

public class RedisPipelineExample {
    public static void main(String[] args) {
        // 创建Redis连接
        Jedis jedis = new Jedis("localhost", 6379);

        // 使用Pipeline
        Pipeline pipeline = jedis.pipelined();
        for (int i = 0; i < 1000; i++) {
            pipeline.set("key" + i, String.valueOf(i));  // 批量设置键值对
        }
        // 执行所有命令
        pipeline.sync();
        
        // 关闭连接
        jedis.close();
    }
}

3. 事务

3.1 概念

事务是一组操作，要么全部成功，要么全部失败。Redis事务通过 MULTI 和 EXEC 命令实现。

3.2 生活场景示例

想象一下，你在银行转账。如果转账成功，账户A减少金额，账户B增加金额；如果转账失败，那么两个账户的金额都不变。这就是一个事务的例子。

3.3 事务的基本操作

  1. 开始事务：
MULTI
  1. 添加命令：
SADD user:1:friends user:2
  1. 提交事务：
EXEC
  1. 回滚事务：
DISCARD

3.4 事务的特点

  • 事务中的命令在执行 EXEC 之前不会真正执行，而是缓存起来。
  • Redis只支持基本的语法错误检查，运行时错误不会回滚之前的命令。

3.5 Java代码示例

以下是使用Java的Jedis库实现事务的代码示例：

java

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class RedisTransactionExample {
    public static void main(String[] args) {
        // 创建Redis连接
        Jedis jedis = new Jedis("localhost", 6379);

        // 开始事务
        Transaction transaction = jedis.multi();

        // 添加命令
        transaction.sadd("user:1:friends", "user:2");

        // 提交事务
        transaction.exec();
        
        // 关闭连接
        jedis.close();
    }
}

4. Lua脚本

4.1 概念

Lua是一种轻量级的脚本语言，Redis内置了Lua支持，可以通过Lua脚本实现复杂的操作。

4.2 生活场景示例

想象一下，你在厨房里做菜。你可以把多个步骤（切菜、煮汤、上菜）写成一个食谱（Lua脚本），一次性完成，而不需要每一步都去问别人怎么做。

4.3 Lua脚本的优点

  1. 减少网络开销：多个命令可以放在同一个脚本中运行。
  2. 原子操作：整个脚本作为一个整体执行，中间不会被其他命令插入。
  3. 复用性：脚本可以被多个客户端复用。

4.4 Java代码示例

以下是使用Java的Jedis库执行Lua脚本的代码示例：

java

import redis.clients.jedis.Jedis;

public class RedisLuaExample {
    public static void main(String[] args) {
        // 创建Redis连接
        Jedis jedis = new Jedis("localhost", 6379);

        // Lua脚本示例
        String luaScript = "return redis.call('GET', KEYS[1])";
        
        // 执行Lua脚本
        String result = (String) jedis.eval(luaScript, 1, "key1");
        System.out.println("Result from Lua script: " + result);
        
        // 关闭连接
        jedis.close();
    }
}

5. Redis与限流

5.1 概念

限流是一种控制访问频率的技术，确保系统在高并发情况下保持稳定。它可以防止系统因请求过多而崩溃，同时也能确保各个用户的请求得到公平处理。

5.2 限流原理

限流的原理可以通过以下算法来实现：

  1. 固定窗口算法：

    • 将时间划分为固定大小的窗口（例如每分钟）。
    • 在每个窗口内，允许一定数量的请求。
    • 如果请求数超过限制，则拒绝后续请求。

    例子：假设每分钟允许10个请求，如果在第一分钟内接收到了10个请求，那么在接下来的请求将被拒绝，直到下一个窗口开始。

    优点：简单易实现，适合于请求量相对平稳的场景。

    应用场景：适用于API调用、用户登录等场景。

  2. 滑动窗口算法：

    • 类似于固定窗口，但时间窗口是动态的，允许在滑动窗口内的请求数。
    • 这样可以更平滑地控制请求，而不容易在窗口边界处出现突发请求。

    优点：可以减少突发请求的情况，适合更复杂的限流需求。

    应用场景：适用于实时性要求较高的系统，如在线支付、抢购等。

  3. 漏桶算法：

    • 设想一个漏桶，桶的容量固定，水以固定速率漏出。
    • 请求流入桶中，如果桶满了，则丢弃请求。
    • 这种算法确保了请求的平稳流入。

    优点：可以平滑处理突发流量，适合高并发场景。

    应用场景：适用于流量控制，如视频流、音频流等。

  4. 令牌桶算法：

    • 先有一个桶，容量是固定的，用来放令牌。
    • 以固定速率向桶放令牌，如果桶满了就不放令牌。
    • 处理请求时，先从桶拿令牌，拿到令牌才能处理请求，没拿到则被限流。

    优点：允许突发请求，但整体速率受限，适合动态流量。

    应用场景：适用于用户注册、消息发送等场景。

5.3 生活场景示例

  • 固定窗口算法：想象你在一个游乐园，每小时只能进入10个人。如果这个小时已经有10个人进入，那么其他人就需要等到下一个小时才能进入。

  • 滑动窗口算法：你在游乐园，每分钟只能进入2个人。如果这一分钟有2个人进入，下一分钟仍然可以接受2个人，但如果在这段时间内有更多的人，就需要等到下一个时间段。

  • 漏桶算法：想象一个水桶，水流入桶中，但桶底有个洞，水以固定速度流出。如果水流入速度过快，桶满了，水就会溢出。

  • 令牌桶算法：你有一个固定容量的桶，每秒可以放入一个令牌。每当你想处理请求时，必须先从桶中拿到令牌。如果没有令牌，就必须等待。

5.4 使用Redis和Lua实现限流

通过Redis的原子操作和Lua脚本，可以实现高效的限流控制，避免系统过载。

5.5 Java代码示例

以下是使用Java的Jedis库和Lua脚本实现四种限流算法的代码示例：

5.5.1 固定窗口算法

java

import redis.clients.jedis.Jedis;

public class FixedWindowRateLimiter {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        String key = "fixed_window_key";
        int limit = 5;  // 每分钟允许的请求数
        int window = 60; // 时间窗口，单位为秒

        // 获取当前请求数
        String currentCount = jedis.get(key);
        if (currentCount == null) {
            jedis.setex(key, window, "1"); // 设置初始请求数
            System.out.println("请求被允许");
        } else {
            int count = Integer.parseInt(currentCount);
            if (count < limit) {
                jedis.incr(key); // 增加请求数
                System.out.println("请求被允许");
            } else {
                System.out.println("请求被拒绝，超出限流");
            }
        }

        jedis.close();
    }
}
5.5.2 滑动窗口算法

java

import redis.clients.jedis.Jedis;

public class SlidingWindowRateLimiter {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        String key = "sliding_window_key";
        int limit = 5;  // 允许的请求数
        int window = 60; // 时间窗口，单位为秒

        long currentTime = System.currentTimeMillis() / 1000;
        long windowStart = currentTime - window;

        // 清理过期请求
        jedis.zremrangeByScore(key, 0, windowStart);

        // 获取当前请求数
        long count = jedis.zcard(key);
        if (count < limit) {
            jedis.zadd(key, currentTime, String.valueOf(currentTime)); // 记录当前请求
            System.out.println("请求被允许");
        } else {
            System.out.println("请求被拒绝，超出限流");
        }

        jedis.close();
    }
}
5.5.3 漏桶算法

java

import redis.clients.jedis.Jedis;

public class LeakyBucketRateLimiter {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        String key = "leaky_bucket_key";
        int capacity = 10;  // 桶的容量
        int leakRate = 1;   // 漏出速率，单位为每秒

        // 获取当前水位
        String currentWater = jedis.get(key);
        if (currentWater == null) {
            currentWater = "0";
            jedis.set(key, currentWater);
        }

        // 计算当前水位
        int water = Integer.parseInt(currentWater);
        water = Math.max(0, water - leakRate); // 漏水
        jedis.set(key, String.valueOf(water)); // 更新水位

        // 判断是否可以加入请求
        if (water < capacity) {
            water++;
            jedis.set(key, String.valueOf(water)); // 加入请求
            System.out.println("请求被允许");
        } else {
            System.out.println("请求被拒绝，超出限流");
        }

        jedis.close();
    }
}
5.5.4 令牌桶算法

java

import redis.clients.jedis.Jedis;

public class TokenBucketRateLimiter {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        String key = "token_bucket_key";
        int capacity = 10;  // 桶的容量
        int refillRate = 1; // 令牌放入速率，单位为每秒

        // 获取当前令牌数
        String currentTokens = jedis.get(key);
        if (currentTokens == null) {
            currentTokens = "0";
            jedis.set(key, currentTokens);
        }

        int tokens = Integer.parseInt(currentTokens);
        tokens = Math.min(capacity, tokens + refillRate); // 令牌放入
        jedis.set(key, String.valueOf(tokens)); // 更新令牌数

        // 判断是否可以处理请求
        if (tokens > 0) {
            tokens--;
            jedis.set(key, String.valueOf(tokens)); // 消耗令牌
            System.out.println("请求被允许");
        } else {
            System.out.println("请求被拒绝，超出限流");
        }

        jedis.close();
    }
}

拾柒mm
关注
  • 19
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redis高级特性和应用：慢查询、Pipeline、事务、Lua
搬砖的小熊猫的博客
06-13 1539
Redis提供了许多高级特性，可以帮助优化和管理系统性能。本文将介绍Redis的慢查询、Pipeline、事务和Lua脚本的使用及其相关配置。
redis高级特性学习(慢查询、Pipeline、事务、Lua)（上）
weixin_43921491的博客
02-08 1313
先有一个桶，桶的容量是固定的。以任意速率向桶流入水滴，如果桶满了则溢出(被丢弃)。桶底下有个洞，按照固定的速率从桶中流出水滴。
Redis高级特性和应用(慢查询、Pipeline、事务、Lua)
weixin_42619556的博客
11-05 250
先有一个桶，桶的容量是固定的。以任意速率向桶流入水滴，如果桶满了则溢出(被丢弃)。桶底下有个洞，按照固定的速率从桶中流出水滴。
Redis高级特性RDB、AOF、事务、Stream、Pipeline和Lua脚本
Minor的Java技术博客
07-09 551
和MySQL一样，Redis也有相应的慢查询统计，Redis的慢查询统计的是步骤3的耗时。Redis提供了一个配置参数来设置慢查询的阈值，默认是10毫秒。其中1+4称为 Round Trip Time (RTT,往返时间)，也就是数据在网络上传输的 时间。 Redis提供了批量操作命令(例如 mget、mset等)，有效地节约 RTT。但大部分命令是不支持批量操作的，需要消耗n次RTT。 Pipeline（流水线)机制能改善上面这类问题,它能将一组Redis命令进行组装,通过传输给Redis,再将这组Re
5、Redis高级特性（慢查询、Pipeline、事务、Lua）
＊King＊的博客
09-21 493
一、慢查询 慢查询日志就是系统在命令执行前后计算每条命令的执行时间，当超过预设阀值,就将这条命令的相关信息（例如:发生时间，耗时，命令的详细信息）记录下来，Redis 也提供了类似的功能。 Redis客户端执行一条命令分为4个部分： 1）发送命令 2）命令排队 3）命令执行 4）返回结果 慢查询只统计步骤3的时间，所以没有慢查询并不代表客户端没有超时问题。 1、慢查询配置 Redis提供了 slowlog-log-slower-than 和 slowlog-max-len 配置 slowlog-log-s
【Redis】高级特性和应用（慢查询、Pipeline、事务、发布/订阅、Stream）
GuLuZaizzz的博客
08-07 272
参数：slowlog-log-slower-than就是时间预设阀值，它的单位是微秒(1秒=1000毫秒=1 000 000微秒)，默认值是10 000，假如执行了一条“很慢”的命令（例如keys *)，如果它的执行时间超过了10 000微秒，也就是10毫秒，那么它将被记录在慢查询日志中。所谓慢查询日志就是系统在命令执行前后计算每条命令的执行时间，当超过预设阀值,就将这条命令的相关信息（例如:发生时间，耗时，命令的详细信息）记录下来，Redis也提供了类似的功能。慢查询的阈值设置，慢查询记录存放位置设置。
【中间件篇-Redis缓存数据库02】Redis高级特性和应用(慢查询、Pipeline、事务、Lua)
studyday1的博客
11-09 1187
先有一个桶，桶的容量是固定的。以任意速率向桶流入水滴，如果桶满了则溢出(被丢弃)。桶底下有个洞，按照固定的速率从桶中流出水滴。
redis事务-pipeline-lua三者区别简单概括
ws_please的博客
07-09 902
简单聊聊
Redis中lua脚本和pipeline的区别
qq_37080455的博客
07-15 398
一、lua脚本一般我会用lua脚本来代替。官方默认lua脚本是原子性的，应该是和MySQL的原子行差不多的。lua脚本的所有命令要么全部执行成功要么全部执行失败。一般是做一些逻辑比较严密的处理。阻塞其他redis操作，直到lua脚本完全执行完毕才会执行其他命令。我认为lua可以执行批量处理如果lua脚本执行的时间太长，那么要优化下lua脚本，因为lua会阻塞其他操作，所以说lua脚本不适合执行太长时间。三、pipeline1、批量处理数据，一次性返回所有结果集。
【中间件篇-Redis缓存数据库】Redis高级特性和应用(慢查询、Pipeline、事务、Lua)
11-09
本文将深入探讨Redis的高级特性，包括慢查询、Pipeline、事务和Lua脚本，帮助你更好地理解和利用这些特性提升系统性能。 ### 1. 慢查询 Redis的慢查询日志（Slow Log）是用于追踪执行时间过长的操作，有助于定位和...
StackExchange.Redis-1.2.6
01-31
- **多模式操作**：支持单个命令、管道（pipeline）和事务（transaction）模式，允许一次性执行多个命令，提高效率。 - **异步编程支持**：提供异步API，适应.NET平台的异步编程模型，便于构建高并发的应用。 - *...
redis 管道（pipeline）、事务（multi）、普通、lua脚本性能对比
muwenbofx的博客
03-01 1236
<?php set_time_limit(0); ini_set('memory_limit','1024M'); $redis = new Redis(); G('1'); $redis->connect('127.0.0.1'); //不具备原子性 ,管道 //$redis->pipeline(); $redis->multi($redis::PIPELINE); for ($i=0;$i<100000;$i++) { $redis->set("test.
Redis 实现哨兵模式
weixin_68398469的博客
08-26 913
哨兵也叫 sentinel，它的作用是能够在后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。Sentinel进程是用于监控redis集群中Master主服务器工作的状态，在Master主服务器发生故障的时候， 可以实现Master和Slave服务器的切换，保证系统的高可用，此功能在redis2.6+的版本已引用，Redis的 哨兵模式到了2.8版本之后就稳定了下来。一般在生产环境也建议使用Redis的2.8版本的以后版本每个哨兵。
利用 Redisson 实现延迟消息队列：一种高效订单取消方案
Takumilove的博客
08-27 759
利用 Redisson 实现延迟消息队列是一种高效的订单管理策略。通过这种方式，我们不仅能够精确地控制订单的处理时效，还可以大幅提升系统的稳定性和响应速度。同时，这种实现方式相对简单，易于维护和扩展。
redis能正常访问，但是springboot编译报错
生而为人我很抱歉
08-27 662
因为你在自定义的 @Configuration 类中没有明确指定配置属性的绑定，或者这个类的加载顺序影响了 Spring Boot 的属性绑定过程。你可以尝试在 MyConf 类上加上 @Order 注解来调整加载顺序，或者确保 MyConf 类不会干扰到 Redis 配置的加载。你可以在 MyConf 类上使用 @ConditionalOnProperty 注解，确保在特定条件下才加载这个配置类，以避免在 Redis 配置加载之前进行不必要的初始化。
Redis从入门到入门（上）
最新发布
Satellite_H的博客
08-31 500
1.Redis概述1.1 什么是Redis1.2 Redis的应用场景2.Linux下Redis的安装与使用2.1 Redis下载2.2 Redis的启动2.3 Redis配置2.4 连接RedisRedis是用C语言开发的一个开源的高性能键值对（key-value）数据库，官方提供测试数据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s ，且Redis通过提供多种键值数据类字符串类型 string散列类型 hash列表类型 list。
零基础学习Redis(8) -- list类型命令使用
2303_78892316的博客
08-28 307
list相当于一个顺序表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值