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

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
-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
-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"