这篇文章，主要是讲 Redis 和 Lua 是如何协同工作的以及 Redis 如何管理 Lua 脚本。
Lua 以可嵌入，轻量，高效，提升静态语言的灵活性，有了 Lua，方便对程序进行改动或拓展，减少编译的次数，在游戏开发中特别常见。举一个在 C 语言中调用 Lua 脚本的例子：
//这是 Lua 所需的三个头文件
//当然，你需要链接到正确的 lib
extern "C"
{
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
}
int main(int argc, char *argv[])
{
lua_State *L = lua_open();
// 此处记住，当你使用的是 5.1 版本以上的 Lua 时，请修改以下两句为
// luaL_openlibs(L);
luaopen_base(L);
luaopen_io(L);
// 记住, 当你使用的是 5.1 版本以上的 Lua 时请使用 luaL_dostring(L,buf);
lua_dofile("script.lua");
lua_close(L);
return 0;
}lua_dofile(”script.lua”); 这一句能为我们提供无限的遐想，开发人员可以在 script.lua 脚本文件中实现程序逻辑，而不需要重新编译 main.cpp 文件。在上面给出的例子中，c 语言执行了 lua 脚本。不仅如此，我们也可以将c 函数注册到 lua 解释器中，从而在 lua 脚本中，调用 c 函数。
从上所说，lua 为静态语言提供更多的灵活性，redis lua 脚本出现之前 Redis 是没有服务器端运算能力的，主要是用来存储，用做缓存，运算是在客户端进行，这里有两个缺点：一、如此会破坏数据的一致性，试想如果两个客户端先后获取（get）一个值，它们分别对键值做不同的修改，然后先后提交结果，最终 Redis 服务器中的结果肯定不是某一方客户端所预期的。二、浪费了数据传输的网络带宽。
lua 出现之后这一问题得到了充分的解决，非常棒！有了 Lua 的支持，客户端可以定义对键值的运算。总之，可以让 Redis 更为灵活。
在 Redis 服务器初始化函数 scriptingInit() 中，初始化了 Lua 的环境。
SHA1 是安全散列算法产生的一个固定长度的序列，你可以把它理解为一个键值。可见 Redis 服务器会保存客户端执行过的 Lua 脚本。这在一个 Lua 脚本需要被经常执行的时候是非常有用的。试想，客户端只需要给定一个 SHA1 序列就可以执行相应的 Lua 脚本了。事实上，EVLASHA 命令就是这么工作的。
重点展开第三、五点。
要在lua 脚本中调用c 函数，会有以下几个步骤：
typedef int (*lua_CFunction) (lua_State *L);在 Redis 初始化的时候，会将 luaRedisPCallCommand(), luaRedisPCallCommand() 两个函数入栈：
void scriptingInit(void) {
......
// 向lua 解释器注册redis 的数据或者变量
/* Register the redis commands table and fields */
lua_newtable(lua);
// 注册redis.call 函数，命令处理函数
/* redis.call */
// 将"call" 入栈，作为key
lua_pushstring(lua,"call");
// 将luaRedisPCallCommand() 函数指针入栈，作为value
lua_pushcfunction(lua,luaRedisCallCommand);
// 弹出"call",luaRedisPCallCommand() 函数指针，即key-value，
// 并在table 中设置key-values
lua_settable(lua,-3);
// 注册redis.pall 函数，命令处理函数
/* redis.pcall */
// 将"pcall" 入栈，作为key
lua_pushstring(lua,"pcall");
// 将luaRedisPCallCommand() 函数指针入栈，作为value
lua_pushcfunction(lua,luaRedisPCallCommand);
// 弹出"pcall",luaRedisPCallCommand() 函数指针，即key-value，
// 并在table 中设置key-values
lua_settable(lua,-3);
......
}经注册后，开发人员可在 Lua 脚本中调用这两个函数，从而在 Lua 脚本也可以执行 Redis 命令，譬如在脚本删除某个键值对。以 luaRedisCallCommand() 为例，当它被回调的时候会完成：
fake client 的好处又一次体现出来了，这和 AOF 的恢复数据过程如出一辙。在 lua 脚本处理期间，Redis 服务器只服务于 fake client。
我们依旧从客户端发送一个 lua 相关命令开始。假定用户发送了 EVAL 命令如下：
eval 1 "set KEY[1] ARGV[1]" views 18000此命令的意图是，将 views 的值设置为 18000。Redis 服务器收到此命令后，会调用对应的命令处理函数evalCommand() 如下：
void evalCommand(redisClient *c) {
evalGenericCommand(c,0);
}
void evalGenericCommand(redisClient *c, int evalsha) {
lua_State *lua = server.lua;
char funcname[43];
long long numkeys;
int delhook = 0, err;
// 随机数的种子，在产生哈希值的时候会用到
redisSrand48(0);
// 关于脏命令的标记
server.lua_random_dirty = 0;
server.lua_write_dirty = 0;
// 检查参数的有效性
if (getLongLongFromObjectOrReply(c,c->argv[2],&numkeys,NULL) != REDIS_OK)
return;
if (numkeys > (c->argc - 3)) {
addReplyError(c,"Number of keys can't be greater than number of args");
return;
}
// 函数名以f_ 开头
funcname[0] = 'f';
funcname[1] = '_';
// 如果没有哈希值，需要计算lua 脚本的哈希值
if (!evalsha) {
// 计算哈希值，会放入到SHA1 -> lua_script 哈希表中
// c->argv[1]->ptr 是用户指定的lua 脚本
// sha1hex() 产生的哈希值存在funcname 中
sha1hex(funcname+2,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
} else {
// 用户自己指定了哈希值
int j;
char *sha = c->argv[1]->ptr;
for (j = 0; j < 40; j++)
funcname[j+2] = tolower(sha[j]);
funcname[42] = '\0';
}
// 将错误处理函数入栈
// lua_getglobal() 会将读取指定的全局变量，且将其入栈
lua_getglobal(lua, "__redis__err__handler");
/* Try to lookup the Lua function */
// 在lua 中查找是否注册了此函数。这一句尝试将funcname 入栈
lua_getglobal(lua, funcname);
if (lua_isnil(lua,-1)) { // funcname 在lua 中不存在
// 将nil 出栈
lua_pop(lua,1); /* remove the nil from the stack */
// 已经确定funcname 在lua 中没有定义，需要创建
if (evalsha) {
lua_pop(lua,1); /* remove the error handler from the stack. */
addReply(c, shared.noscripterr);
return;
}
// 创建lua 函数funcname
// c->argv[1] 指向用户指定的lua 脚本
if (luaCreateFunction(c,lua,funcname,c->argv[1]) == REDIS_ERR) {
lua_pop(lua,1);
return;
}
// 现在lua 中已经有funcname 这个全局变量了，将其读取并入栈，
// 准备调用
lua_getglobal(lua, funcname);
redisAssert(!lua_isnil(lua,-1));
}
// 设置参数，包括键和值
luaSetGlobalArray(lua,"KEYS",c->argv+3,numkeys);
luaSetGlobalArray(lua,"ARGV",c->argv+3+numkeys,c->argc-3-numkeys);
// 选择数据集，lua_client 有专用的数据集
/* Select the right DB in the context of the Lua client */
selectDb(server.lua_client,c->db->id);
// 设置超时回调函数，以在lua 脚本执行过长时间的时候停止脚本的运行
server.lua_caller = c;
server.lua_time_start = ustime()/1000;
server.lua_kill = 0;
if (server.lua_time_limit > 0 && server.masterhost == NULL) {
// 当lua 解释器执行了100000，luaMaskCountHook() 会被调用
lua_sethook(lua,luaMaskCountHook,LUA_MASKCOUNT,100000);
delhook = 1;
}
// 现在，我们确定函数已经注册成功了. 可以直接调用lua 脚本
err = lua_pcall(lua,0,1,-2);
// 删除超时回调函数
if (delhook) lua_sethook(lua,luaMaskCountHook,0,0); /* Disable hook */
// 如果已经超时了，说明lua 脚本已在超时后背SCRPIT KILL 终结了
// 恢复监听发送lua 脚本命令的客户端
if (server.lua_timedout) {
server.lua_timedout = 0;
aeCreateFileEvent(server.el,c->fd,AE_READABLE,
readQueryFromClient,c);
}
// lua_caller 置空
server.lua_caller = NULL;
// 执行lua 脚本用的是lua 脚本执行专用的数据集。现在恢复原有的数据集
selectDb(c,server.lua_client->db->id); /* set DB ID from Lua client */
// Garbage collection 垃圾回收
lua_gc(lua,LUA_GCSTEP,1);
// 处理执行lua 脚本的错误
if (err) {
// 告知客户端
addReplyErrorFormat(c,"Error running script (call to %s): %s\n",
funcname, lua_tostring(lua,-1));
lua_pop(lua,2); /* Consume the Lua reply and remove error handler. */
// 成功了
} else {
/* On success convert the Lua return value into Redis protocol, and
* send it to * the client. */
luaReplyToRedisReply(c,lua); /* Convert and consume the reply. */
lua_pop(lua,1); /* Remove the error handler. */
}
// 将lua 脚本发布到主从复制上，并写入AOF 文件
......
}对应 lua 脚本的执行流程图：
在解释脏命令之前，先交代一点。
Redis 服务器执行的 Lua 脚本和普通的命令一样，都是会写入 AOF 文件和发布至主从复制连接上的。以主从复制为例，将 Lua 脚本中发生的数据变更发布到从机上，有两种方法。一，和普通的命令一样，只要涉及写的操作，都发布到从机上；二、直接将 Lua 脚本发送给从机。实际上，两种方法都可以的，数据变更都能得到传播，但首先，第一种方法中普通命令会被转化为 Redis 通信协议的格式，和 Lua 脚本文本大小比较起来，会浪费更多的带宽；其次，第一种方法也会浪费较多的 CPU 的资源，因为从机收到了 Redis 通信协议的格式的命令后，还需要转换为普通的命令，然后才是执行，这比纯粹的执行 lua 脚本，会浪费更多的 CPU 资源。明显，第二种方法是更好的。这一点 Redis 做的比较细致。
上面的结果是，直接将 Lua 脚本发送给从机。但这会产生一个问题。举例一个 Lua 脚本：
-- lua scrpit
local some_key
some_key = redis.call('RANDOMKEY') -- <--- TODO nil
redis.call('set',some_key,'123')上面脚本想要做的是，从 Redis 服务器中随机选取一个键，将其值设置为 123。从 RANDOMKEY 命令的命令处理函数来看，其调用了 random() 函数，如此一来问题就来了：当 lua 脚本被发布到不同的从机上时，random() 调用返回的结果是不同的，因此主从机的数据就不一致了。
因此在 Redis 服务器配置选项目设置了两个变量来解决这个问题：
// 在lua 脚本中发生了写操作
int lua_write_dirty; /* True if a write command was called during the
execution of the current script. */
// 在lua 脚本发生了未决的操作，譬如RANDOMKEY 命令操作
int lua_random_dirty; /* True if a random command was called during the
execution of the current script. */在执行 Lua 脚本之前，这两个参数会被置零。在执行 Lua 脚本中，执行命令操作之前，Redis 会检测写操作之前是否执行了 RANDOMKEY 命令，是则会禁止接下来的写操作，因为未决的操作会被传播到从机上；否则会尝试更新上面两个变量，如果发现写操作 lua_write_dirty = 1；如果发现未决操作，lua_random_dirty = 1。对于这段话的表述，有下面的流程图，大家也可以翻阅 luaRedisGenericCommand() 这个函数：
如上所说，需要传播 Lua 脚本中的数据变更，Redis 的做法是直接将 lua 脚本发送给从机和写入 AOF 文件的。
Redis 的做法是，修改执行 Lua 脚本客户端的参数为“EVAL”和相应的lua 脚本文本，至于发送到从机和写入 AOF 文件，交由主从复制机制和 AOF 持久化机制来完成。下面摘一段代码：
void evalGenericCommand(redisClient *c, int evalsha) {
......
if (evalsha) {
if (!replicationScriptCacheExists(c->argv[1]->ptr)) {
/* This script is not in our script cache, replicate it as
* EVAL, then add it into the script cache, as from now on
* slaves and AOF know about it. */
// 从server.lua_scripts 获取lua 脚本
// c->argv[1]->ptr 是SHA1
robj *script = dictFetchValue(server.lua_scripts,c->argv[1]->ptr);
// 添加到主从复制专用的脚本缓存中
replicationScriptCacheAdd(c->argv[1]->ptr);
redisAssertWithInfo(c,NULL,script != NULL);
// 重写命令
// 参数1 为：EVAL
// 参数2 为：lua_script
// 如此一来在执行AOF 持久化和主从复制的时候，lua 脚本就能得到传播
rewriteClientCommandArgument(c,0,
resetRefCount(createStringObject("EVAL",4)));
rewriteClientCommandArgument(c,1,script);
}
}
}Redis 服务器的工作模式是单进程单线程，因为开发人员在写 Lua 脚本的时候应该特别注意时间复杂度的问题，不要让 Lua 脚本影响整个 Redis 服务器的性能。
FROM: http://wiki.jikexueyuan.com/project/redis/lua.html