Redis开发与运维读书笔记-第三章-实用功能介绍(一)

最新推荐文章于 2024-05-08 06:41:46 发布

矫首遐观

最新推荐文章于 2024-05-08 06:41:46 发布

阅读量687

点赞数 1

分类专栏：读书笔记文章标签： Redis慢查询分析 Redis Shell Redis中的事务和Lua Redis中的Pipeline

本文链接：https://blog.csdn.net/u010408502/article/details/82699135

版权

读书笔记专栏收录该内容

25 篇文章 1 订阅

订阅专栏

Redis提供的5种数据结构已经足够强大，但除此之外，Redis还提供了诸如慢查询分析、功能强大的Redis Shell、Pipeline、事务与Lua脚本、 Bitmaps、HyperLogLog、发布订阅、GEO等附加功能，这些功能可以在某些场景发挥重要的作用，本章将介绍如下内容：
·慢查询分析：通过慢查询分析，找到有问题的命令进行优化。
·Redis Shell：功能强大的Redis Shell会有意想不到的实用功能。
·Pipeline：通过Pipeline（管道或者流水线）机制有效提高客户端性能。
·事务与Lua：制作自己的专属原子命令。
·Bitmaps：通过在字符串数据结构上使用位操作，有效节省内存，为开发提供新的思路。
·HyperLogLog：一种基于概率的新算法，难以想象地节省内存空间。
·发布订阅：基于发布订阅模式的消息通信机制。
·GEO：Redis3.2提供了基于地理位置信息的功能。

一. 慢查询分析

许多存储系统（例如MySQL）提供慢查询日志帮助开发和运维人员定位系统存在的慢操作。所谓慢查询日志就是系统在命令执行前后计算每条命令的执行时间，当超过预设阀值，就将这条命令的相关信息（例如：发生时间，耗时，命令的详细信息）记录下来，Redis也提供了类似的功能。
如下图所示，Redis客户端执行一条命令分为如下4个部分：

1）发送命令 2）命令排队 3）命令执行 4）返回结果
需要注意，慢查询只统计步骤3）的时间，所以没有慢查询并不代表客户端没有超时问题。
(一)慢查询的两个配置参数
对于慢查询功能，需要明确两件事：
·预设阀值怎么设置？
·慢查询记录存放在哪？
Redis提供了slowlog-log-slower-than和slowlog-max-len配置来解决这两个问题。从字面意思就可以看出，slowlog-log-slower-than就是那个预设阀值，它的单位是微秒（1秒=1000毫秒=1000000微秒），默认值是10000，假如执行了一条“很慢”的命令（例如keys*），如果它的执行时间超过了10000微秒，那么它将被记录在慢查询日志中。

如果slowlog-log-slower-than=0会记录所有的命令，slowlog-log-slowerthan<0对于任何命令都不会进行记录。
从字面意思看，slowlog-max-len只是说明了慢查询日志最多存储多少条，并没有说明存放在哪里？实际上Redis使用了一个列表来存储慢查询日志，slowlog-max-len就是列表的最大长度。一个新的命令满足慢查询条件时被插入到这个列表中，当慢查询日志列表已处于其最大长度时，最早插入的一个命令将从列表中移出，例如slowlog-max-len设置为5，当有第6条慢查询插入的话，那么队头的第一条数据就出列，第6条慢查询就会入列

在Redis中有两种修改配置的方法，一种是修改配置文件，另一种是使用config set命令动态修改。例如下面使用config set命令将slowlog-log-slowerthan设置为20000微秒，slowlog-max-len设置为1000：

config set slowlog-log-slower-than 20000 
config set slowlog-max-len 1000 
config rewrite

如果要Redis将配置持久化到本地配置文件，需要执行config rewrite命令:

虽然慢查询日志是存放在Redis内存列表中的，但是Redis并没有暴露这个列表的键，而是通过一组命令来实现对慢查询日志的访问和管理。下面介绍这几个命令。
（1）获取慢查询日志(slowlog get [n])

下面操作返回当前Redis的慢查询，参数n可以指定条数：

127.0.0.1:6379> slowlog get 
1)  1) (integer) 666
    2) (integer) 1456786500    
    3) (integer) 11615    
    4) 1) "BGREWRITEAOF" 
2)  1) (integer) 665    
    2) (integer) 1456718400    
    3) (integer) 12006    
    4) 1) "SETEX"       
       2) "video_info_200"       
       3) "300"       
       4) "2" ...

可以看到每个慢查询日志有4个属性组成，分别是慢查询日志的标识 id、发生时间戳、命令耗时、执行命令和参数

（2）获取慢查询日志列表当前的长度(slowlog len)

例如，当前Redis中有45条慢查询：

127.0.0.1:6379> slowlog len 
(integer) 45

（3）慢查询日志重置(slowlog reset)

实际是对列表做清理操作，例如：

127.0.0.1:6379> slowlog len 
(integer) 45 
127.0.0.1:6379> slowlog reset 
OK 
127.0.0.1:6379> slowlog len 
(integer) 0

(二)最佳实践

慢查询功能可以有效地帮助我们找到Redis可能存在的瓶颈，但在实际使用过程中要注意以下几点：
·slowlog-max-len配置建议：线上建议调大慢查询列表，记录慢查询时 Redis会对长命令做截断操作，并不会占用大量内存。增大慢查询列表可以减缓慢查询被剔除的可能，例如线上可设置为1000以上。
·slowlog-log-slower-than配置建议：默认值超过10毫秒判定为慢查询，需要根据Redis并发量调整该值。由于Redis采用单线程响应命令，对于高流量的场景，如果命令执行时间在1毫秒以上，那么Redis最多可支撑OPS不到 1000。因此对于高OPS场景的Redis建议设置为1毫秒。
·慢查询只记录命令执行时间，并不包括命令排队和网络传输时间。因此客户端执行命令的时间会大于命令实际执行时间。因为命令执行排队机制，慢查询会导致其他命令级联阻塞，因此当客户端出现请求超时，需要检查该时间点是否有对应的慢查询，从而分析出是否为慢查询导致的命令级联阻塞。
·由于慢查询日志是一个先进先出的队列，也就是说如果慢查询比较多的情况下，可能会丢失部分慢查询命令，为了防止这种情况发生，可以定期执行slow get命令将慢查询日志持久化到其他存储中（例如MySQL），然后可以制作可视化界面进行查询

二.Redis Shell

Redis提供了redis-cli、redis-server、redis-benchmark等Shell工具。它们虽然比较简单，但是麻雀虽小五脏俱全，有时可以很巧妙地解决一些问题。
(一)redis-cli详解

redis-cli，包括-h、-p参数，但是除了这些参数，还有很多有用的参数，要了解redis-cli的全部参数，可以执行redis-cli-help命令来进行查看，下面将对一些重要参数的含义以及使用场景进行说明。
1.-r
-r（repeat）选项代表将命令执行多次，例如下面操作将会执行三次ping命令：

redis-cli -r 3 ping 
PONG 
PONG 
PONG

2.-i
-i（interval）选项代表每隔几秒执行一次命令，但是-i选项必须和-r选项一起使用，下面的操作会每隔1秒执行一次ping命令，一共执行5次：

$ redis-cli -r 5 -i 1 ping 
PONG 
PONG 
PONG 
PONG 
PONG

注意-i的单位是秒，不支持毫秒为单位，但是如果想以每隔10毫秒执行一次，可以用-i0.01，例如：

$ redis-cli -r 5 -i 0.01 ping 
PONG 
PONG
PONG
PONG
PONG

例如下面的操作利用-r和-i选项，每隔1秒输出内存的使用量，一共输出 100次：

redis-cli -r 100 -i 1 info | grep used_memory_human 
used_memory_human:2.95G 
used_memory_human:2.95G 
...................... 
used_memory_human:2.94G

3.-x
-x选项代表从标准输入（stdin）读取数据作为redis-cli的最后一个参数，例如下面的操作会将字符串world作为set hello的值：

$ echo "world" | redis-cli -x set hello OK

4.-c
-c（cluster）选项是连接Redis Cluster节点时需要使用的，-c选项可以防止moved和ask异常

5.-a
如果Redis配置了密码，可以用-a（auth）选项，有了这个选项就不需要手动输入auth命令。
6.--scan和--pattern
--scan选项和--pattern选项用于扫描指定模式的键，相当于使用scan命令
7.--slave
--slave选项是把当前客户端模拟成当前Redis节点的从节点，可以用来获取当前Redis节点的更新操作,合理的利用这个选项可以记录当前连接Redis节点的一些更新操作，这些更新操作很可能是实际开发业务时需要的数据。
下面开启第一个客户端，使用--slave选项，看到同步已完成：

$ redis-cli --slave 
SYNC with master, discarding 72 bytes of bulk transfer... 
SYNC done. Logging commands from master.

再开启另一个客户端做一些更新操作：

redis-cli 
127.0.0.1:6379> set hello world 
OK 
127.0.0.1:6379> set a b 
OK 
127.0.0.1:6379> incr count 
1 
127.0.0.1:6379> get hello 
"world"

第一个客户端会收到Redis节点的更新操作：

redis-cli --slave 
SYNC with master, discarding 72 bytes of bulk transfer... 
SYNC done. Logging commands from master. 
"PING" 
"PING" 
"PING" 
"PING" 
"PING" 
"SELECT","0" 
"set","hello","world" 
"set","a","b" 
"PING" 
"incr","count"

PING命令是由于主从复制产生的

8.--rdb
--rdb选项会请求Redis实例生成并发送RDB持久化文件，保存在本地。可使用它做持久化文件的定期备份。
9.--pipe
--pipe选项用于将命令封装成Redis通信协议定义的数据格式，批量发送给Redis执行，例如下面操作同时执行了set hello world和incr counter两条命令：

echo -en '*3\r\n$3\r\nSET\r\n$5\r\nhello\r\n$5\r\nworld\r\n*2\r\n$4\r\nincr\r\    n$7\r\ncounter\r\n' | redis-cli --pipe

10.--bigkeys
--bigkeys选项使用scan命令对Redis的键进行采样，从中找到内存占用比较大的键值，这些键可能是系统的瓶颈。
11.--eval
--eval选项用于执行指定Lua脚本

12.--latency

latency有三个选项，分别是--latency、--latency-history、--latency-dist。它们都可以检测网络延迟，对于Redis的开发和运维非常有帮助。
该选项可以测试客户端到目标Redis的网络延迟，例如当前拓扑结构如下图所示。客户端B和Redis在机房B，客户端A在机房A，机房A和机房B是跨地区的。

redis-cli -h {machineB} --latency 
min: 0, max: 1, avg: 0.07 (4211 samples)

客户端A：

redis-cli -h {machineB} --latency 
min: 0, max: 2, avg: 1.04 (2096 samples)

可以看到客户端A由于距离Redis比较远，平均网络延迟会稍微高一些。
（2）--latency-history
--latency的执行结果只有一条，如果想以分时段的形式了解延迟信息，可以使用--latency-history选项：

redis-cli -h 10.10.xx.xx --latency-history 
min: 0, max: 1, avg: 0.28 (1330 samples) -- 15.01 seconds range… 
min: 0, max: 1, avg: 0.05 (1364 samples) -- 15.01 seconds range

可以看到延时信息每15秒输出一次，可以通过-i参数控制间隔时间。
（3）--latency-dist
该选项会使用统计图表的形式从控制台输出延迟统计信息。

redis-cli --stat 
------- data ------ --------------------- load -------------------- - child 
keys       mem      clients blocked requests            connections          
2451959    3.43G    1162    0       7426132839 (+0)     1337356     
2451958    3.42G    1162    0       7426133645 (+806)   1337356     … 
2452182    3.43G    1161    0       7426150275 (+1303)  1337356

14.--raw和--no-raw
--no-raw选项是要求命令的返回结果必须是原始的格式，--raw恰恰相反，返回格式化后的结果。
在Redis中设置一个中文的value：

$redis-cli set hello "你好" 
OK

如果正常执行get或者使用--no-raw选项，那么返回的结果是二进制格式：

$redis-cli get hello 
"\xe4\xbd\xa0\xe5\xa5\xbd" 
$redis-cli --no-raw get hello 
"\xe4\xbd\xa0\xe5\xa5\xbd"

如果使用了--raw选项，将会返回中文：

$redis-cli --raw get hello你好

(二)redis-server详解

redis-server除了启动Redis外，还有一个--test-memory选项。redis-server-test-memory可以用来检测当前操作系统能否稳定地分配指定容量的内存给 Redis，通过这种检测可以有效避免因为内存问题造成Redis崩溃，例如下面操作检测当前操作系统能否提供1G的内存给Redis：

redis-server --test-memory 1024

整个内存检测的时间比较长。当输出passed this test时说明内存检测完毕，最后会提示--test-memory只是简单检测，如果有质疑可以使用更加专业的内存检测工具：

Please keep the test running several minutes per GB of memory. 
Also check http:// www.memtest86.com/ and http:// pyropus.ca/software/memtester/ ................忽略检测细节................ 
Your memory passed this test. Please if you are still in doubt use the following two tools: 1) memtest86: http:// www.memtest86.com/ 
2) memtester: http:// pyropus.ca/software/memtester/

(三)redis-benchmark详解
redis-benchmark可以为Redis做基准性能测试，它提供了很多选项帮助开发和运维人员测试Redis的相关性能，下面分别介绍这些选项。

1.-c
-c（clients）选项代表客户端的并发数量（默认是50）。
2.-n<requests>
-n（num）选项代表客户端请求总量（默认是100000）。
例如redis-benchmark-c100-n20000代表100各个客户端同时请求Redis，一共执行20000次。redis-benchmark会对各类数据结构的命令进行测试，并给出性能指标：

====== GET ======    
20000 requests completed in 0.27 seconds    
100 parallel clients    
3 bytes payload    
keep alive: 1 
99.11% <= 1 milliseconds 
100.00% <= 1 milliseconds    
73529.41 requests per second

3.-q
-q选项仅仅显示redis-benchmark的requests per second信息，例如：

$redis-benchmark -c 100 -n 20000 -q 
PING_INLINE: 74349.45 requests per second 
PING_BULK: 68728.52 requests per second 
SET: 71174.38 requests per second… 
LRANGE_500 (first 450 elements): 11299.44 requests per second 
LRANGE_600 (first 600 elements): 9319.67 requests per second 
MSET (10 keys): 70671.38 requests per second

4.-r
在一个空的Redis上执行了redis-benchmark会发现只有3个键：

127.0.0.1:6379> dbsize 
(integer) 3 
127.0.0.1:6379> keys * 
1) "counter:__rand_int__" 
2) "mylist" 
3) "key:__rand_int__"

如果想向Redis插入更多的键，可以执行使用-r（random）选项，可以向 Redis插入更多随机的键。

$redis-benchmark -c 100 -n 20000 -r 10000

-r选项会在key、counter键上加一个12位的后缀，-r10000代表只对后四位做随机处理（-r不是随机数的个数）。例如上面操作后，key的数量和结果结构如下：

127.0.0.1:6379> dbsize 
(integer) 18641 
127.0.0.1:6379> scan 0 
1) "14336" 
2)  1) "key:000000004580"    
    2) "key:000000004519"    
        …   
    10) "key:000000002113"

5.-P
-P选项代表每个请求pipeline的数据量（默认为1）。
6.-k<boolean>
-k选项代表客户端是否使用keepalive，1为使用，0为不使用，默认值为1。
7.-t
-t选项可以对指定命令进行基准测试。

redis-benchmark -t get,set -q 
SET: 98619.32 requests per second 
GET: 97560.98 requests per second

8.--csv
--csv选项会将结果按照csv格式输出，便于后续处理，如导出到Excel等。

redis-benchmark -t get,set --csv 
"SET","81300.81" 
"GET","79051.38"

三.Pipeline

Pipeline概念:Redis客户端执行一条命令分为如下四个过程：
1）发送命令2）命令排队3）命令执行4）返回结果
其中1）+4）称为Round Trip Time（RTT，往返时间）。
Redis提供了批量操作命令（例如mget、mset等），有效地节约RTT。但大部分命令是不支持批量操作的，例如要执行n次hgetall命令，并没有 mhgetall命令存在，需要消耗n次RTT。Redis的客户端和服务端可能部署在不同的机器上。例如客户端在北京，Redis服务端在上海，两地直线距离约为 1300公里，那么1次RTT时间=1300×2/（300000×2/3）=13毫秒（光在真空中传输速度为每秒30万公里，这里假设光纤为光速的2/3），那么客户端在1秒内大约只能执行80次左右的命令，这个和Redis的高并发高吞吐特性背道而驰。Pipeline（流水线）机制能改善上面这类问题，它能将一组Redis命令进行组装，通过一次RTT传输给Redis，再将这组Redis命令的执行结果按顺序返回给客户端.

redis-cli的--pipe选项实际上就是使用Pipeline机制，例如下面操作将set hello world和incr counter两条命令组装：

echo -en '*3\r\n$3\r\nSET\r\n$5\r\nhello\r\n$5\r\nworld\r\n*2\r\n$4\r\nincr\r\    n$7\r\ncounter\r\n' | redis-cli --pipe

但大部分开发人员更倾向于使用高级语言客户端中的Pipeline，目前大部分Redis客户端都支持Pipeline，后面介绍如何通过Java的Redis客户端Jedis使用Pipeline功能。
·Pipeline执行速度一般比逐条执行要快。
·客户端和服务端的网络延时越大，Pipeline的效果越明显。

原生批量命令与Pipeline对比:

可以使用Pipeline模拟出批量操作的效果，但是在使用时要注意它与原生批量命令的区别，具体包含以下几点：
·原生批量命令是原子的，Pipeline是非原子的。
·原生批量命令是一个命令对应多个key，Pipeline支持多个命令。
·原生批量命令是Redis服务端支持实现的，而Pipeline需要服务端和客户端的共同实现。
Pipeline虽然好用，但是每次Pipeline组装的命令个数不能没有节制，否则一次组装Pipeline数据量过大，一方面会增加客户端的等待时间，另一方面会造成一定的网络阻塞，可以将一次包含大量命令的Pipeline拆分成多次较小的Pipeline来完成。
Pipeline只能操作一个Redis实例，但是即使在分布式Redis场景中，也可以作为批量操作的重要优化手段,具体细节见第11章。

四.事务与Lua

为了保证多条命令组合的原子性，Redis提供了简单的事务功能以及集成Lua脚本来解决这个问题。本节首先简单介绍Redis中事务的使用方法以及它的局限性，之后重点介绍Lua语言的基本使用方法，以及如何将Redis和 Lua脚本进行集成，最后给出Redis管理Lua脚本的相关命令。

事务表示一组动作，要么全部执行，要么全部不执行。例如在社交网站上用户A关注了用户B，那么需要在用户A的关注表中加入用户B，并且在用户B的粉丝表中添加用户A，这两个行为要么全部执行，要么全部不执行，否则会出现数据不一致的情况。
Redis提供了简单的事务功能，将一组需要一起执行的命令放到multi和 exec两个命令之间。multi命令代表事务开始，exec命令代表事务结束，它们之间的命令是原子顺序执行的,下面操作实现了上述用户关注问题。

127.0.0.1:6379> multi 
OK 
127.0.0.1:6379> sadd user:a:follow user:b 
QUEUED 
127.0.0.1:6379> sadd user:b:fans user:a 
QUEUED

可以看到sadd命令此时的返回结果是QUEUED，代表命令并没有真正执行，而是暂时保存在Redis中。如果此时另一个客户端执行sismember user： a：follow user：b返回结果应该为0。

127.0.0.1:6379> sismember user:a:follow user:b 
(integer) 0

只有当exec执行后，用户A关注用户B的行为才算完成，如下所示返回的两个结果对应sadd命令。

127.0.0.1:6379> exec 
1) (integer) 1
2) (integer) 1 
127.0.0.1:6379> sismember user:a:follow user:b 
(integer) 1

如果要停止事务的执行，可以使用discard命令代替exec命令即可。

127.0.0.1:6379> discard 
OK 
127.0.0.1:6379> sismember user:a:follow user:b 
(integer) 0

如果事务中的命令出现错误，Redis的处理机制也不尽相同。
1.命令错误

例如下面操作错将set写成了sett，属于语法错误，会造成整个事务无法执行，key和counter的值未发生变化：

127.0.0.1:6388> mget key counter 
1) "hello" 
2) "100" 
127.0.0.1:6388> multi 
OK 
127.0.0.1:6388> sett key world 
(error) ERR unknown command 'sett' 
127.0.0.1:6388> incr counter 
QUEUED 
127.0.0.1:6388> exec 
(error) EXECABORT Transaction discarded because of previous errors. 
127.0.0.1:6388> mget key counter 
1) "hello" 
2) "100"

2.运行时错误
例如用户B在添加粉丝列表时，误把sadd命令写成了zadd命令，这种就是运行时命令，因为语法是正确的：

127.0.0.1:6379> multi 
OK 
127.0.0.1:6379> sadd user:a:follow user:b 
QUEUED
127.0.0.1:6379> zadd user:b:fans 1 user:a 
QUEUED 
127.0.0.1:6379> exec 
1) (integer) 1 
2) (error) WRONGTYPE Operation against a key holding the wrong kind of value 127.0.0.1:6379> sismember user:a:follow user:b 
(integer) 1

可以看到Redis并不支持回滚功能，sadd user：a：follow user：b命令已经执行成功，开发人员需要自己修复这类问题。
有些应用场景需要在事务之前，确保事务中的key没有被其他客户端修改过，才执行事务，否则不执行（类似乐观锁）。Redis提供了watch命令来解决这类问题，下表展示了两个客户端执行命令的时序。

时间点	客户端1	客户端2
T1	set key "java"
T2	watch key
T3	multi
T4		append key python
T5	append key Jedis
T6	exec
T7	get key

可以看到“客户端-1”在执行multi之前执行了watch命令，“客户端-2”在“客户端-1”执行exec之前修改了key值，造成事务没有执行（exec结果为nil），整个代码如下所示：

#T1：客户端1 
127.0.0.1:6379> set key "java" 
OK 
#T2：客户端1 
127.0.0.1:6379> watch key 
OK 
#T3：客户端1 
127.0.0.1:6379> multi 
OK 
#T4：客户端2 
127.0.0.1:6379> append key python 
(integer) 11 
#T5：客户端1
127.0.0.1:6379> append key jedis 
QUEUED 
#T6：客户端1 
127.0.0.1:6379> exec 
(nil) 
#T7：客户端1 
127.0.0.1:6379> get key 
"javapython"

Redis提供了简单的事务，之所以说它简单，主要是因为它不支持事务中的回滚特性，同时无法实现命令之间的逻辑关系计算，当然也体现了 Redis的“keep it simple”的特性，下面介绍的Lua脚本同样可以实现事务的相关功能，但是功能要强大很多。

Lua用法简述:

1.数据类型及其逻辑处理
Lua语言提供了如下几种数据类型：booleans（布尔）、numbers（数值）、strings（字符串）、tables（表格），和许多高级语言相比，相对简单。下面将结合例子对Lua的基本数据类型和逻辑处理进行说明。
（1）字符串
下面定义一个字符串类型的数据：

local strings val = "world"

其中，local代表val是一个局部变量，如果没有local代表是全局变量。 print函数可以打印出变量的值，例如下面代码将打印world，其中"--"是Lua语言的注释。

-- 结果是"world" 
print(hello)

（2）数组
在Lua中，如果要使用类似数组的功能，可以用tables类型，下面代码使用定义了一个tables类型的变量myArray，但和大多数编程语言不同的是， Lua的数组下标从1开始计算：

local tables myArray = {"redis", "jedis", true, 88.0} 
--true 
print(myArray[3])

如果想遍历这个数组，可以使用for和while，这些关键字和许多编程语言是一致的。
（a）for
下面代码会计算1到100的和，关键字for以end作为结束符：

local int sum = 0 
for i = 1, 100 
do    
sum = sum + i 
end 
-- 输出结果为5050 
print(sum)

要遍历myArray，首先需要知道tables的长度，只需要在变量前加一个#号即可：

for i = 1, #myArray 
do    
print(myArray[i]) 
end

除此之外，Lua还提供了内置函数ipairs，使用for index，value ipairs（tables）可以遍历出所有的索引下标和值：

for index,value in ipairs(myArray) 
do    
print(index)    
print(value) 
end

（b）while
下面代码同样会计算1到100的和，只不过使用的是while循环，while循环同样以end作为结束符。

local int sum = 0 
local int i = 0 
while i <= 100 
do    
    sum = sum +i    
    i = i + 1 
end 
--输出结果为5050 
print(sum)

（c）if else
要确定数组中是否包含了jedis，有则打印true，注意if以end结尾，if后紧跟then：

local tables myArray = {"redis", "jedis", true, 88.0} 
for i = 1, #myArray 
do    
    if myArray[i] == "jedis"    
    then        
        print("true")        
        break    
    else        
    --do nothing    
    end 
end

（3）哈希
如果要使用类似哈希的功能，同样可以使用tables类型，例如下面代码定义了一个tables，每个元素包含了key和value，其中strings1..string2是将两个字符串进行连接：

local tables user_1 = {age = 28, name = "tome"} 
--user_1 age is 28 
print("user_1 age is " .. user_1["age"])

如果要遍历user_1，可以使用Lua的内置函数pairs：

for key,value in pairs(user_1) 
do print(key .. value) 
end

2.函数定义
在Lua中，函数以function开头，以end结尾，funcName是函数名，中间部分是函数体：

function funcName()    
... 
end 
contact函数将两个字符串拼接： 
function contact(str1, str2)    
return str1 .. str2 
end 
--"hello world" 
print(contact("hello ", "world"))

更多了解,可以去官方网站进行学习（http://www.lua.org/）

Redis与Lua

1.在Redis中使用Lua
在Redis中执行Lua脚本有两种方法：eval和evalsha。
（1）eval

eval 脚本内容 key个数 key列表 参数列表

(2)下面例子使用了key列表和参数列表来为Lua脚本提供更多的灵活性：

127.0.0.1:6379> eval 'return "hello " .. KEYS[1] .. ARGV[1]' 1 redis world 
"hello redisworld"

此时KEYS[1]="redis"，ARGV[1]="world"，所以最终的返回结果是"hello redisworld"。如果Lua脚本较长，还可以使用redis-cli--eval直接执行文件。eval命令和--eval参数本质是一样的，客户端如果想执行Lua脚本，首先在客户端编写好Lua脚本代码，然后把脚本作为字符串发送给服务端，服务端会将执行结果返回给客户端，整个过程如下图所示。

（2）evalsha
除了使用eval，Redis还提供了evalsha命令来执行Lua脚本。如下图所示，首先要将Lua脚本加载到Redis服务端，得到该脚本的SHA1校验和， evalsha命令使用SHA1作为参数可以直接执行对应Lua脚本，避免每次发送 Lua脚本的开销。这样客户端就不需要每次执行脚本内容，而脚本也会常驻在服务端，脚本功能得到了复用。

加载脚本：script load命令可以将脚本内容加载到Redis内存中，例如下面将lua_get.lua加载到Redis中，得到SHA1 为："7413dc2440db1fea7c0a0bde841fa68eefaf149c"

# redis-cli script load "$(cat lua_get.lua)" 
"7413dc2440db1fea7c0a0bde841fa68eefaf149c"

执行脚本：evalsha的使用方法如下，参数使用SHA1值，执行逻辑和 eval一致。

evalsha 脚本SHA1值 key个数 key列表 参数列表

所以只需要执行如下操作，就可以调用lua_get.lua脚本：

127.0.0.1:6379> evalsha 7413dc2440db1fea7c0a0bde841fa68eefaf149c 1 redis world 
"hello redisworld"

2.Lua的Redis API

Lua可以使用redis.call函数实现对Redis的访问，例如下面代码是Lua使用 redis.call调用了Redis的set和get操作：

redis.call("set", "hello", "world") 
redis.call("get", "hello")

放在Redis的执行效果如下：

127.0.0.1:6379> eval 'return redis.call("get", KEYS[1])' 1 hello 
"world"

除此之外Lua还可以使用redis.pcall函数实现对Redis的调用，redis.call和 redis.pcall的不同在于，如果redis.call执行失败，那么脚本执行结束会直接返回错误，而redis.pcall会忽略错误继续执行脚本，所以在实际开发中要根据具体的应用场景进行函数的选择。
Lua脚本功能为Redis开发和运维人员带来如下三个好处：
·Lua脚本在Redis中是原子执行的，执行过程中间不会插入其他命令。
·Lua脚本可以帮助开发和运维人员创造出自己定制的命令，并可以将这些命令常驻在Redis内存中，实现复用的效果。
·Lua脚本可以将多条命令一次性打包，有效地减少网络开销。
下面以一个例子说明Lua脚本的使用，当前列表记录着热门用户的id，假设这个列表有5个元素，如下所示：

127.0.0.1:6379> lrange hot:user:list 0 -1 
1) "user:1:ratio" 
2) "user:8:ratio" 
3) "user:3:ratio" 
4) "user:99:ratio" 
5) "user:72:ratio"

user：{id}：ratio代表用户的热度，它本身又是一个字符串类型的键：

127.0.0.1:6379> mget user:1:ratio user:8:ratio user:3:ratio user:99:ratio     user:72:ratio 1) "986" 
2) "762" 
3) "556" 
4) "400" 
5) "101"

现要求将列表内所有的键对应热度做加1操作，并且保证是原子执行，此功能可以利用Lua脚本来实现。
1）将列表中所有元素取出，赋值给mylist：

local mylist = redis.call("lrange", KEYS[1], 0, -1)

2）定义局部变量count=0，这个count就是最后incr的总次数：

local count = 0

3）遍历mylist中所有元素，每次做完count自增，最后返回count：

for index,key in ipairs(mylist) 
do    
    redis.call("incr",key)    
    count = count + 1 
end 
return count

将上述脚本写入lrange_and_mincr.lua文件中，并执行如下操作，返回结果为5。

redis-cli --eval lrange_and_mincr.lua  hot:user:list 
(integer) 5

执行后所有用户的热度自增1：

127.0.0.1:6379> mget user:1:ratio user:8:ratio user:3:ratio user:99:ratio     user:72:ratio 1) "987" 
2) "763" 
3) "557"
4) "401" 
5) "102"

矫首遐观

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Redis开发与运维读书笔记-第三章-实用功能介绍(一)

Redis提供的5种数据结构已经足够强大，但除此之外，Redis还提供了诸如慢查询分析、功能强大的Redis Shell、Pipeline、事务与Lua脚本、 Bitmaps、HyperLogLog、发布订阅、GEO等附加功能，这些功能可以在某些场景发挥重要的作用，本章将介绍如下内容：·慢查询分析：通过慢查询分析，找到有问题的命令进行优化。·Redis Shell：功能强大的Redis Shel...
复制链接

扫一扫