5、Redis高级特性（慢查询、Pipeline、事务、Lua）

最新推荐文章于 2024-04-11 12:20:41 发布
最新推荐文章于 2024-04-11 12:20:41 发布
阅读量459 收藏 3
点赞数
分类专栏： Redis系列 文章标签： redis lua 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wlchina123/article/details/120405703
版权

一、慢查询

慢查询日志就是系统在命令执行前后计算每条命令的执行时间，当超过预设阀值,就将这条命令的相关信息（例如:发生时间，耗时，命令的详细信息）记录下来，Redis 也提供了类似的功能。

Redis客户端执行一条命令分为4个部分：
在这里插入图片描述

1）发送命令 2）命令排队 3）命令执行 4）返回结果

慢查询只统计步骤3的时间，所以没有慢查询并不代表客户端没有超时问题。

1、慢查询配置

Redis提供了 slowlog-log-slower-than 和 slowlog-max-len 配置

slowlog-log-slower-than预设阀值，它的单位是微秒（1秒=1000毫秒=1000 000微秒），默认值是10000，假如执行一条很慢的命令（例keys *），如果它的执行时间超过了10000微秒，也就是10毫秒，那么它将被记录在慢查询日志中。

slowlog-max-len 用来设置慢查询日志最多存储多少条，并没有说明存放在哪。实际上 Redis 使用了一个列表来存储慢查询日志，slowlog-max-len 就是列表的最 大长度。当慢查询日志列表被填满后，新的慢查询命令则会继续入队，队列中的第一条数据机会出列。

设置慢查询配置有两种方式：

1、执行以下命令

config set slowlog-log-slower-than 10000  //10毫秒

使用config set完后，苦想将配置持久化保存到Redis.conf，要执行

config rewrite

2、修改配置文件

Redis.conf修改：找到slowlog-log-slower-than 10000，修改保存即可。slowlog-log-slower-than =0记录所有命令-1命令都不记录。

2、慢查询操作命令

slowlog get  //获取队列里慢查询的命令
slowlog len  //获取慢查询列表当前的长度
slowlog reset //慢查询列表清理（重置），执行后再查slowlog len此时返回0清空
slow-max-len配置建议：线上可设置1000以上
slowlog-log-slower-than配置建议：默认为10毫秒，根据redis并发量来调整，对于高并发比建议为1毫秒

慢查询是先进先出的队列，访问日志记录出列丢失，需定期执行slowlog get，将结果存储到其它设备中（如mysql）

二、Pipeline

Pipeline（流水线）机制：它能将一组Redis命令进行组装，通过一次RTT（RTT:往返时间，也就是数据在网络上传输的时间）传输给Redis，再将这组Redis命令的执行结果按顺序返回给客户端，没有使用Pipeline执行了n条命令，整个过程需要n次RTT。使用了Pipeline执行了n次命令，整个过程需要1次RTT。

代码样例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Pipeline;

import java.util.List;

@Component
public class RedisPipeline {

    @Autowired
    private JedisPool jedisPool;

    public List<Object> plGet(List<String> keys) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            Pipeline pipelined = jedis.pipelined();

            for(String key:keys){
                pipelined.get(key);
            }
            return pipelined.syncAndReturnAll();
        } catch (Exception e) {
            throw new RuntimeException("执行Pipeline获取失败！",e);
        } finally {
            jedis.close();
        }
    }

    public void plSet(List<String> keys,List<String> values) {
        if(keys.size()!=values.size()) {
            throw new RuntimeException("key和value个数不匹配！");
        }
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            Pipeline pipelined = jedis.pipelined();
            for(int i=0;i<keys.size();i++){
                pipelined.set(keys.get(i),values.get(i));
            }
            pipelined.sync();
        } catch (Exception e) {
            throw new RuntimeException("执行Pipeline设值失败！",e);
        } finally {
            jedis.close();
        }
    }
}

测试类

import cn.enjoyedu.redis.adv.RedisPipeline;
import cn.enjoyedu.redis.redisbase.basetypes.RedisString;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.List;

@SpringBootTest
public class TestRedisPipeline {

    @Autowired
    private RedisPipeline redisPipeline;
    @Autowired
    private RedisString redisString;

    private static final int TEST_COUNT = 1000;

    @Test
    public void testPipeline() {
        long setStart = System.currentTimeMillis();
        for (int i = 0; i < TEST_COUNT; i++) {
            redisString.set("testStringM:key_" + i, String.valueOf(i));
        }
        long setEnd = System.currentTimeMillis();
        System.out.println("非pipeline操作"+TEST_COUNT+"次字符串数据类型set写入，耗时：" + (setEnd - setStart) + "毫秒");

        List<String> keys = new ArrayList<>(TEST_COUNT);
        List<String> values= new ArrayList<>(TEST_COUNT);
        for (int i = 0; i < keys.size(); i++) {
            keys.add("testpipelineM:key_"+i);
            values.add(String.valueOf(i));
        }
        long pipelineStart = System.currentTimeMillis();
        redisPipeline.plSet(keys,values);
        long pipelineEnd = System.currentTimeMillis();
        System.out.println("pipeline操作"+TEST_COUNT+"次字符串数据类型set写入，耗时：" + (pipelineEnd - pipelineStart) + "毫秒");
    }

}

测试结果：
在这里插入图片描述

三、事务

Redis提供了简单的事务功能，将一组需要一起执行的命令放到multi和exec两个命令之间，multi命令代表事务开始，exec命令代表事务结束，如果要停止事务的执行，可以使用discard命令代替exec命令即可。
在这里插入图片描述
可以看到sadd命令此时的返回结果是QUEUED，代表命令并没有真正执行，而是暂时保存在Redis中的一个缓存队列，所以 discard 也只是丢弃这个缓存队列中的未执行命令，并不会回滚已经操作过的数据，这一点要和关系型数据库的Rollback 操作区分开。只有当exec执行后，返回两个结果对应的sadd命令。

1、如果命令错误，比如set写成了sett，属于语法错误，会造成整个事务无法执行。

2、如果运行时错误，比如用户B在添加数据时，误把sadd命令写成了zadd命令，这种就是运行时命令，此时Redis并不支持回滚功能。

有时需要在事务之间，确保事务中的key没有被其他客户端修改过才执行事务，否则不执行（类似乐观锁）。Redis提供了watch命令来解决这类问题

客户端1：
在这里插入图片描述

客户端2：
在这里插入图片描述
再回到客户端1
在这里插入图片描述

可以看到客户端1在执行multi之前执行了watch命令，客户端2在客户端1执行exec之间修改了key值，造成了客户端1事务没有执行exec结果为nil

Redis客户端中的事务使用代码：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Transaction;

import java.util.List;

@Component
public class RedisTransaction {

    public final static String RS_TRANS_NS = "rts:";

    @Autowired
    private JedisPool jedisPool;

    public List<Object> transaction(String... watchKeys){
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            if(watchKeys.length>0){
                /*使用watch功能*/
                String watchResult = jedis.watch(watchKeys);
                if(!"OK".equals(watchResult)) {
                    throw new RuntimeException("执行watch失败:"+watchResult);
                }
            }
            Transaction multi = jedis.multi();
            multi.set(RS_TRANS_NS+"testa1","a1");
            multi.set(RS_TRANS_NS+"testa2","a2");
            multi.set(RS_TRANS_NS+"testa3","a3");
            List<Object> execResult = multi.exec();
            if(execResult==null){
                throw new RuntimeException("事务无法执行，监视的key被修改:"+watchKeys);
            }
            System.out.println(execResult);
            return execResult;
        } catch (Exception e) {
            throw new RuntimeException("执行Redis事务失败！",e);
        } finally {
            if(watchKeys.length>0){
                jedis.unwatch();/*前面如果watch了，这里就要unwatch*/
            }
            jedis.close();
        }
    }
}

测试：

@SpringBootTest
public class TestRedisTransaction {

    @Autowired
    private RedisTransaction redisTransaction;

    @Test
    public void testTransaction() {
        redisTransaction.transaction();
    }

}

测试结果：
在这里插入图片描述

四、Lua

LUA脚本语言是C开发的，类似存储过程。

使用LUA脚本的好处：

  • 减少网络开销，在Lua脚本中可以把多个命令放在同一个脚本中运行
  • 原子操作，Redis会将整个脚本作为一个整体执行，中间不会被其他命令插入
  • 复用性，客户端发送的脚本会存储在Redis中，其他客户端可以复用这个脚本来完成同样的逻辑

1、安装Lua

Lua在Linux中的安装：

1、下载lua的tar.gz的源码包

wget http://www.lua.org/ftp/lua-5.3.6.tar.gz

2、解压

tar -zxvf lua-5.3.6.tar.gz

3、进入解压目录

cd lua-5.3.6
make linux
make install   //需要在root用户下运行

如报错，找不到readline/readline.h，可以root用户下通过yum命令安装

yum -y install libtermcap-devel ncurses-devel libevent-devel readline-devel

安装完成再

make linux
make install

最后，直接进入lua命令即可进入lua的控制台：
在这里插入图片描述
在这里插入图片描述

2、Lua基本语法

  • 单行注释： –
  • 多行注释： --[[ --]]
  • Lua关键字：

and break do else elseif end false for function if in local nil not or repeat return then true until while

Lua数据类型：lua是动态类型语言，变量不要类型定义，只需要为变量赋值，值可以存储在变量中，作为参数传递或结果返回。

Lua中有8个基本类型：

  • nil 表示一个无效值（在条件表达式中相当于false）

  • boolean 包含两个值 : false和true

  • number 表示双精度类型的实浮点数

  • string 字符串由一对双引号或单引号来表示，也可以[[与]]表示

  • function 由c或lua编写的函数

  • userdata 表示任意存储在变量中的c数据结构

  • thread 表示执行的独立线数，用于执行协同程序

  • table lua中的表，可以做为数组，也可以作为hash
    在这里插入图片描述
    在这里插入图片描述

Lua中的函数

在lua中，函数以function开头，以end结尾，funcName是函数名，中间部分是函数体

function funcName () 
	--[[
	函数内容 
	--]] 
end

定义一个字符串连接函数：
在这里插入图片描述

Lua变量

Lua变量有全局变量和局部变量

lua中的变量全是全局变量，除非用local显式声明为局部变量的。局部变量的作用域为从声明位置开始到所在语句块结束。

变量的默认值均为nil。
在这里插入图片描述

Lua中的控制语句

循环控制：

Lua支持while循环、for循环，repeat…until循环和循环嵌套，同时lua提供了break语句和goto语句

数值for循环

for var=exp1,exp2,exp3 do
  <执行体>
end

var从exp1变化到exp2,每次变化以exp3为步长递寺var，并执行一次“执行体”。exp3是可选的，如果不指定，默认为1。
在这里插入图片描述

泛型for循环

例如：打印数组a的所有值
在这里插入图片描述

i 是数组索引值，v是对应索引的数组元素值。ipairs是lua提供的一个迭代器函数，用来迭代数组。
在这里插入图片描述

while 循环 
while(condition) 
do 
	statements 
end

在这里插入图片描述

if条件控制

Lua支持if语句、if…else语句和if嵌套语句

if语句语法：

if(布尔表达式) 
then
	--[ 在布尔表达式为 true 时执行的语句 --] 
end

if…else语句语法：

if(布尔表达式) 
then
	--[ 布尔表达式为 true 时执行该语句块 --] 
else
	--[ 布尔表达式为 false 时执行该语句块 --]
end

Lua运算符

算术运算符

+ 加法

- 减法

* 乘法

/ 除法

% 取余

^ 乘幂

- 负号

关系运算符

== 等于

~= 不等于

> 大于

< 小于

>= 大于等于

<= 小于等于

逻辑运算符

and 逻辑与操作符

or 逻辑或操作符

not 逻辑非操作符

3、Redis中的Lua

eval命令

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

命令说明：

  • （1）script 参数：是一段 Lua 脚本程序，它会被运行在 Redis 服务器上下文中，这段脚本不必（也不应该）定义为一个 Lua 函数。
  • （2）numkeys 参数：用于指定键名参数的个数。
  • （3）key [key …] 参数： 从 EVAL 的第三个参数开始算起，使用了 numkeys 个键（key），表示在脚本中所用到的那些 Redis 键（key），这些键名参数可以在 Lua 中通过全局变量 KEYS 数组，用 1 为基址的形式访问（KEYS[1],KEYS[2]···）。
  • （4）arg [arg …]参数：可以在 Lua 中通过全局变量 ARGV 数组访问，访问的形式和 KEYS 变量类似（ARGV[1],ARGV[2]···）。
    在这里插入图片描述

Lua脚本中调用Redis命令

eval "return redis.call('mset',KEYS[1],ARGV[1],KEYS[2],ARGV[2])" 2 key1 key2 first second
eval "return redis.call('set',KEYS[1],ARGV[1])" 1 key1 newfirst

在这里插入图片描述

evalsha命令

  • script flush ：清除所有脚本缓存。
  • script exists ：根据给定的脚本校验，检查指定的脚本是否存在于脚本缓存。
  • script load ：将一个脚本装入脚本缓存，返回 SHA1 摘要，但并不立即运行它。
  • script kill ：杀死当前正在运行的脚本。
    在这里插入图片描述

3、Java对Lua的支持

在java生态中，对Lua的支持是LuaJ，是一个java的Lua解释器，基于Lua5.2.x版本

Java客户端使用Lua脚本

Maven依赖

<dependency> 
	<groupId>org.luaj</groupId> 
	<artifactId>luaj-jse</artifactId> 					<version>3.0.1</version> 
</dependency>

案例代码

/*基于redis的一个限流功能*/
@Component
public class RedisLua {

    public final static String RS_LUA_NS = "rlilf:";
    /*第一次使用incr对KEY（某个IP作为KEY）加一，如果是第一次访问，
    使用expire设置一个超时时间，这个超时时间作为Value第一个参数传入，
    如果现在递增的数目大于输入的第二个Value参数，返回失败标记，否则成功。
    redis的超时时间到了，这个Key消失，又可以访问
        local num = redis.call('incr', KEYS[1])
        if tonumber(num) == 1 then
            redis.call('expire', KEYS[1], ARGV[1])
            return 1
        elseif tonumber(num) > tonumber(ARGV[2]) then
            return 0
        else
            return 1
        end
    * */
    public final static String LUA_SCRIPTS =
            "local num = redis.call('incr', KEYS[1])\n" +
            "if tonumber(num) == 1 then\n" +
            "\tredis.call('expire', KEYS[1], ARGV[1])\n" +
            "\treturn 1\n" +
            "elseif tonumber(num) > tonumber(ARGV[2]) then\n" +
            "\treturn 0\n" +
            "else \n" +
            "\treturn 1\n" +
            "end";

    @Autowired
    private JedisPool jedisPool;

    public String loadScripts(){
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String sha =jedis.scriptLoad(LUA_SCRIPTS);
            return sha;
        } catch (Exception e) {
            throw new RuntimeException("加载脚本失败！",e);
        } finally {
            jedis.close();
        }
    }

    public String ipLimitFlow(String ip){
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String result = jedis.evalsha("9ac7623ae2435baf9ebf3ef4d21cde13de60e85c",
                    Arrays.asList(RS_LUA_NS+ip),Arrays.asList("60","2")).toString();
            return result;
        } catch (Exception e) {
            throw new RuntimeException("执行脚本失败！",e);
        } finally {
            jedis.close();
        }
    }
}

测试

@SpringBootTest
public class TestRedisLua {

    @Autowired
    private RedisLua redisLua;

    @Test
    public void testLoad() {
        System.out.println(redisLua.loadScripts());
    }

    @Test
    public void tesIpLimitFlow() {
        System.out.println(redisLua.ipLimitFlow("localhost"));
    }

}

测试结果
在这里插入图片描述

＊King＊
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis实操代码 发布/订阅、Lua、PipeLine等
11-10
redis实操代码 发布/订阅、Lua、PipeLine等
详解Redis的慢查询日志
12-14
Redis慢查询日志帮助开发和运维人员定位系统存在的慢操作。慢查询日志就是系统在命令执行前后计算每条命令的执行时间，当超过预设阀值，就将这条命令的相关信息（慢查询ID，发生时间戳，耗时，命令的详细信息）记录下来。 Redis客户端一条命令分为如下四部分执行： 需要注意的是，慢查询日志只是统计步骤3）执行命令的时间，所以慢查询并不代表客户端没有超时问题。需要注意的是，慢查询日志只是统计步骤3）执行命令的时间，所以慢查询并不代表客户端没有超时问题。 一、慢查询的配置参数： 慢查询的预设阀值 slowlog-log-slower-than slowlog-log-slower-than参数就是
Redis分析慢查询操作的实例教程
12-16
什么是慢查询 慢查询的作用：通过慢查询分析，找到有问题的命令进行优化。 和mysql的慢SQL日志分析一样，redis也有类似的功能，来帮助定位一些慢查询操作。 Redis slowlog是Redis用来记录查询执行时间的日志系统。 查询执行时间指的是不包括像客户端响应(talking)、发送回复等IO操作，而单单是执行一个查询命令所耗费的时间。 另外，slow log保存在内存里面，读写速度非常快，因此你可以放心地使用它，不必担心因为开启slow log而损害Redis的速度。 慢查询日志四个属性： 1、第一个字段是每个慢查询唯一标识。 2、处理完命令后的时间戳 3、执行改名了所需要的
Redis的高级特性
chy1984的博客
08-19 667
发布/订阅(publish/subscribe)是一种消息通信模式，redis客户端订阅redis服务器上的一个或多个channel（管道、频道），客户端发布消息到redis服务器中的某个channel后，redis服务器会将消息推送给所有订阅了此channel的redis客户端。redis的事务只是把多个命令打包，放在一个队列中执行，只是保证了事务中指令的串行执行，并没有给事务添加原子性的保障机制，redis的事务具有隔离性但不具备原子性，执行失败时不会回滚。和Bitmap一样，不精确、有一定的错误率。
Redis面试常问点
sowhat
12-13 667
文章目录zookeeper文件系统监听通知机制Zookeeper能做什么自己的一些理解：ZooKeeper安装下载安装包然后解压默认文件重命名修改zoo.cfg配置文件新建myid文件ZooKeeper端口解释启动zookeeper服务启动zookeeper客户端检验服务是否可用参考 zookeeper 官网：http://zookeeper.apache.org/ ZooKeeper： 是一个开...
Redis高级特性RDB、AOF、事务、Stream、Pipeline和Lua脚本
Minor的Java技术博客
07-09 385
和MySQL一样，Redis也有相应的慢查询统计，Redis的慢查询统计的是步骤3的耗时。Redis提供了一个配置参数来设置慢查询的阈值，默认是10毫秒。其中1+4称为 Round Trip Time (RTT,往返时间)，也就是数据在网络上传输的 时间。 Redis提供了批量操作命令(例如 mget、mset等)，有效地节约 RTT。但大部分命令是不支持批量操作的，需要消耗n次RTT。 Pipeline（流水线)机制能改善上面这类问题,它能将一组Redis命令进行组装,通过传输给Redis,再将这组Re
redis高级特性学习(慢查询、Pipeline、事务、Lua)（上）
weixin_43921491的博客
02-08 1247
先有一个桶，桶的容量是固定的。以任意速率向桶流入水滴，如果桶满了则溢出(被丢弃)。桶底下有个洞，按照固定的速率从桶中流出水滴。
Redis慢查询设置和查询
weixin_30469895的博客
04-15 109
Redis 慢查询 （配置文件中需要设置两个参数） 转自：https://segmentfault.com/a/1190000009915519 config set slowlog-log-slower-than 100 （单位ms） config set slowlog-max-len 1024 日志最多存个数 config rew...
【Redis学习笔记（十四）】之 发布与订阅，事务，Lua脚本，慢查询日志
开发小鸽
03-05 251
文章目录本文章由公号【开发小鸽】发布！欢迎关注！！！一． 发布与订阅（一） 概述（二） 频道的订阅和退订（三） 模式的订阅和退订（四） 发送消息（五） 查看订阅消息1. PUBSUB CHANNELS [pattern]2. PUBSUB NUMSUB3. PUBSUB NUMPAT二． 事务（一） 概述（二） 事务的实现1. 事务开始2. 命令入队3. 事务队列4. 执行事务（三） WATCH命令1. 概述2. 实现3. 监视机制的触发4. 判断事务是否可执行（四） 事务的ACID1. 原子性2. 一致性
Redis之事务（二）
慢一拍的coder
08-31 90
目录 写在前面 开工 1：是什么 2：能做什么 3：怎么做 3.1：MULTI：开启一个事务 3.2：EXEC：执行（commit） 3.3：DISCARD：放弃当前事务，放弃队列中所有命令 3.4：UNWATCH：取消所有监控的key 3.5：WATCH：监控一个或多个key，如果在事务执行之前key被其他命令动过，那么当前事务被打断 4：几种常见的事务 总结 写在前面...
【中间件篇-Redis缓存数据库】Redis高级特性和应用(慢查询、Pipeline、事务、Lua)
11-09
【中间件篇-Redis缓存数据库】Redis高级特性和应用(慢查询、Pipeline、事务、Lua)
redis中采用管道进行sadd操作
weixin_39935887的博客
02-27 3070
管道中sadd函数定义如下: public transient Long sAdd(byte[]key, byte[]... values) 第一个参数为byte类型的一维数组，第二个参数可以传入0到多个Object对象或者传入一个Object[]数组。 现在有一个需求，就是将Set&lt;String&gt;中的数据存储到某个key的value中，此时我们该怎么去将这个Set容器中的数据...
redis大幅性能提升之使用管道（PipeLine）和批量（Batch）操作
dotNET跨平台
07-05 686
前段时间在做用户画像的时候，遇到了这样的一个问题，记录某一个商品的用户购买群，刚好这种需求就可以用到Redis中的Set，key作为productID，value就是具体的custome...
Redis_Jedis简易指南
lixiaoxiong的专栏
04-28 391
本文转自：http://blog.csdn.net/u013256816/article/details/51120023Redis 简介Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。 Redis 与其他 key - value 缓存产品有以下三个特点：Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 Redi
Redis Pipelining 底层原理分析及实践
最新发布
vivo互联网技术
04-11 1079
Redis是一种基于客户端-服务端模型以及请求/响应的TCP服务。在遇到批处理命令执行时，Redis提供了Pipelining(管道)来提升批处理性能。本文结合实践分析了Spring Boot框架下Redis的Lettuce客户端和Redisson客户端对Pipeline特性的支持原理，并针对实践过程中遇到的问题进行了分析，可以帮助开发者了解不同客户端对Pipeline支持原理及避免实际使用中出现问题。
03.Redis---Java操作Redis---Jedis
Yjh_pythonking的博客
10-19 318
Jedis是Java中操作redis的一个客户端，类似通过jdbc访问mysql数据库。 一、基本操作 1.添加pom依赖 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.5.2</version> </dependency> <dependen
Redis管道(Pipeline)，Lua脚本
weixin_43251629的博客
09-01 978
管道（Pipeline） 管道的作用就是可以让客户端一次性发送多个请求，将所有的命令都放在一个缓冲区中最后一次性将所有命令打包发送到服务端。 管道的作用就是降低我们与redis交互的网络开销，原本每次请求都需要建立一次连接，而现在将多次请求打包只需要建立一次连接。 当然也不是打包的请求越多越好，因为redis必须要将所有的请求的结果进行缓存，请求越多所消耗的内存也自然越多。 管道是不具备原子性的，有可能打包的多个命令中执行过程中有某一条请求执行失败，那也不会影响其他的命令继续执行的。 管道代码演示 pu
redis 教程 6（Redis 的Pipeline , Lua）
一人码农
04-21 481
redis的pipeline， lua
redis pipeline+lua+es
hbyhhh的博客
05-23 239
elasticsearch 1.倒排索引 与数据库的对应 ElasticSearch Index(索引） Type(类型） Document（文档） Fiedls（字段） MySQL Database(数据库) Table(表） Row（行） Column(列） 2.postman查询所有的索引 http://127.0.0.1:9200/_cat/indices?v 添加索引：get 删除索引：delete 添加数据内容
黑马redis笔记高级 Op
09-12
4. 慢查询日志（Slowlog）：Redis可以记录执行时间超过指定阈值的命令，并将这些命令及其执行时间保存在慢查询日志中。可以通过SLOWLOG GET命令获取慢查询日志。 5. 排序（Sorted Set）：Redis的Sorted Set是一种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值