redis实现了对"事务"的支持，核心函数都在这里
摘抄对于事务的定义：是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行
它的4个特性：原子性、一致性、隔离性、持久性
redis在事务的执行中并没有提供回滚操作，它会按顺序执行完队列中的所有命令而不管中间是否有命令出错(当然，执行出错的命令会打印出错信息)，所以一致性没办法保障。
相关的command:
struct redisCommand redisCommandTable[] = {
...
{"multi", multiCommand, 1,"rsF",0,NULL,0,0,0,0,0}, //标识事务的开始
{"exec", execCommand, 1,"sM", 0,NULL,0,0,0,0,0}, //事务的提交(commit)
{"discard", discardCommand, 1,"rsF",0,NULL,0,0,0,0,0}, //取消事务(不是回滚)
...
{"watch", watchCommand, -2,"rsF",0,NULL,1,-1,1,0,0},
{"unwatch", unwatchCommand, 1,"rsF",0,NULL,0,0,0,0,0},
...
}初始化一个multi state，就是简单地将commands指针设置为空，count设置为0。代码如下：
/* Client state initialization for MULTI/EXEC */
void initClientMultiState(redisClient *c) {
c->mstate.commands = NULL;
c->mstate.count = 0;
}queueMultiCommand用来将命令加入待执行队列，MULTI到EXEC之间的命令都是通过它来入队的，核心代码如下:
/* 把待执行的command加入到队列。
* 每次来一个新的command就要realloc一次空间，而且只增加一个command的大小。
* 为什么不用预分配再适当扩大的办法？类似于sdsMakeRoomFor的做法？
*/
void queueMultiCommand(redisClient *c) {
multiCmd *mc;
int j;
c->mstate.commands = zrealloc(c->mstate.commands,
sizeof(multiCmd)*(c->mstate.count+1));
mc = c->mstate.commands+c->mstate.count;
mc->cmd = c->cmd;
mc->argc = c->argc;
mc->argv = zmalloc(sizeof(robj*)*c->argc);
memcpy(mc->argv,c->argv,sizeof(robj*)*c->argc);
for (j = 0; j < c->argc; j++)
incrRefCount(mc->argv[j]);
c->mstate.count++;
}discardTransaction用来取消某一个事务，discard命令、exec返回之前都会调用它。它除了释放mstate.commands数组之外，最后还会unwatch all keys
void discardTransaction(redisClient *c) {
freeClientMultiState(c);
initClientMultiState(c);
c->flags &= ~(REDIS_MULTI|REDIS_DIRTY_CAS|REDIS_DIRTY_EXEC);
unwatchAllKeys(c);
}flagTransaction用来把一个进入multi状态的client打上标记：REDIS_DIRTY_EXEC
/* Flag the transacation as DIRTY_EXEC so that EXEC will fail.
* Should be called every time there is an error while queueing a command. */
/* 只在processCommand中发现是不合法的命令时会被调用
* 问题是，在processCommand当中，调用这个函数之后都返回OK了，不会进行后面的处理(比如执行或者queue)，打这个标记有什么作用？
* EXEC在执行之前会检查是否有这个标记，只要有这个标记，就返回错误并取消事务
* 所以，事务中的一系列命令，只要有一个命令的格式错误，其它的全部不执行
*/
void flagTransaction(redisClient *c) {
if (c->flags & REDIS_MULTI)
c->flags |= REDIS_DIRTY_EXEC;
}multiCommand是multi命令的处理入口，它只是检查状态之后，简单地将client标记为REDIS_MULTI状态
void multiCommand(redisClient *c) {
if (c->flags & REDIS_MULTI) {
addReplyError(c,"MULTI calls can not be nested");
return;
}
c->flags |= REDIS_MULTI;
addReply(c,shared.ok);
}discard命令的处理函数
void discardCommand(redisClient *c) {
if (!(c->flags & REDIS_MULTI)) {
addReplyError(c,"DISCARD without MULTI");
return;
}
discardTransaction(c);
addReply(c,shared.ok);
}exec命令的处理函数
void execCommand(redisClient *c) {
int j;
robj **orig_argv;
int orig_argc;
struct redisCommand *orig_cmd;
int must_propagate = 0; /* Need to propagate MULTI/EXEC to AOF / slaves? */
/* 必须是MULTI状态 */
if (!(c->flags & REDIS_MULTI)) {
addReplyError(c,"EXEC without MULTI");
return;
}
/* Check if we need to abort the EXEC because:
* 1) Some WATCHed key was touched.
* 2) There was a previous error while queueing commands.
* A failed EXEC in the first case returns a multi bulk nil object
* (technically it is not an error but a special behavior), while
* in the second an EXECABORT error is returned. */
/* 执行之前，检查一下异常状态。其中REDIS_DIRTY_CAS会在touchWatchedKey中被打上，这样就实现了原子操作 */
if (c->flags & (REDIS_DIRTY_CAS|REDIS_DIRTY_EXEC)) {
addReply(c, c->flags & REDIS_DIRTY_EXEC ? shared.execaborterr :
shared.nullmultibulk);
discardTransaction(c);
goto handle_monitor;
}
/* Exec all the queued commands */
/* 为什么不做unwatch就会浪费cpu?
* 因为下面要执行的一系列命令可能会修改某些key，如果不unwatch all，就可能会做一些不必要的touchWatchedKey操作？
*/
unwatchAllKeys(c); /* Unwatch ASAP otherwise we'll waste CPU cycles */
/* 记录原始(当前)的cmd相关指针 */
orig_argv = c->argv;
orig_argc = c->argc;
orig_cmd = c->cmd;
/* 首先给客户返回要执行的命令数量 */
addReplyMultiBulkLen(c,c->mstate.count);
for (j = 0; j < c->mstate.count; j++) {
c->argc = c->mstate.commands[j].argc;
c->argv = c->mstate.commands[j].argv;
c->cmd = c->mstate.commands[j].cmd;
/* Propagate a MULTI request once we encounter the first write op.
* This way we'll deliver the MULTI/..../EXEC block as a whole and
* both the AOF and the replication link will have the same consistency
* and atomicity guarantees. */
/* 如果有写命令，只进行一次propagate，保证AOF和replication的一致性和原子性 */
if (!must_propagate && !(c->cmd->flags & REDIS_CMD_READONLY)) {
execCommandPropagateMulti(c);
must_propagate = 1;
}
/* 执行命令，就算该命令执行失败也不会回滚而是继续执行下一条 */
call(c,REDIS_CALL_FULL);
/* Commands may alter argc/argv, restore mstate. */
/* 命令的执行过程可能会修改参数，记录新的参数内容 */
c->mstate.commands[j].argc = c->argc;
c->mstate.commands[j].argv = c->argv;
c->mstate.commands[j].cmd = c->cmd;
}
/* 恢复 */
c->argv = orig_argv;
c->argc = orig_argc;
c->cmd = orig_cmd;
/* 执行完成之后，结束事务 */
discardTransaction(c);
/* Make sure the EXEC command will be propagated as well if MULTI
* was already propagated. */
/* 如果执行过propagate，dirty计数加1 */
if (must_propagate) server.dirty++;
handle_monitor:
/* Send EXEC to clients waiting data from MONITOR. We do it here
* since the natural order of commands execution is actually:
* MUTLI, EXEC, ... commands inside transaction ...
* Instead EXEC is flagged as REDIS_CMD_SKIP_MONITOR in the command
* table, and we do it here with correct ordering. */
/* 如果有client在monitor上等待输出(监控？)，将这次的命令信息(不是MULTI...EXEC之间执行的命令，MULTI...EXEC之间的命令在上面执行call的时候会发到monitor)发送给相应的client */
if (listLength(server.monitors) && !server.loading)
replicationFeedMonitors(c,server.monitors,c->db->id,c->argv,c->argc);
}上面的部分是multi命令执行需要的所有相关函数。但是仅仅只有上面的部分的话，也只是实现了一种"批量处理"的方式，还不能算是事务。下面提到的watch就是用来保证原子性。
代码中，对WATCH的注释是: CAS alike for MULTI/EXEC。
CAS应该是Compare and Swap，是一种实现乐观锁的机制，它的原理：认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可
具体到用watch机制来保证操作的原子性(下面这个加1的操作可以用incr一条命令实现，这里只是为了演示):
1. watch key
2. val = get key
3. val = val + 1
4. MULTI
5. set key value
6. EXEC
对于上面的这一系列操作，如果在EXEC命令之前，有其它client修改了key对应的value，那么这一次的EXEC是不会执行的，需要重新执行上面的所有步骤(EXEC结束时会unwatch all keys)。
所以redis里事务的原子性必须要依靠watch来保证。
watch的实现中使用了下面这个结构体，用来将key和db进行关联
/* ===================== WATCH (CAS alike for MULTI/EXEC) ===================
*
* The implementation uses a per-DB hash table mapping keys to list of clients
* WATCHing those keys, so that given a key that is going to be modified
* we can mark all the associated clients as dirty.
*
* Also every client contains a list of WATCHed keys so that's possible to
* un-watch such keys when the client is freed or when UNWATCH is called. */
/* In the client->watched_keys list we need to use watchedKey structures
* as in order to identify a key in Redis we need both the key name and the
* DB */
/* redisClient结构中用list来组织该client watch的所有keys
* redisDB结构中用dict来组织watch某一个key的所有client列表
*/
typedef struct watchedKey {
robj *key;
redisDb *db;
} watchedKey;watch key的核心操作
/*
* 1. 如果client的watched_keys列表上已经有了这个key，直接返回
* 2. 如果没有，则加到相应的db中，再加到client的watched_keys列表上
* 3. 增加这个key的引用计数
*/
void watchForKey(redisClient *c, robj *key) {
list *clients = NULL;
listIter li;
listNode *ln;
watchedKey *wk;
/* Check if we are already watching for this key */
listRewind(c->watched_keys,&li);
while((ln = listNext(&li))) {
wk = listNodeValue(ln);
if (wk->db == c->db && equalStringObjects(key,wk->key))
return; /* Key already watched */
}
/* This key is not already watched in this DB. Let's add it */
clients = dictFetchValue(c->db->watched_keys,key);
if (!clients) {
clients = listCreate();
dictAdd(c->db->watched_keys,key,clients);
incrRefCount(key);
}
listAddNodeTail(clients,c);
/* Add the new key to the list of keys watched by this client */
wk = zmalloc(sizeof(*wk));
wk->key = key;
wk->db = c->db;
incrRefCount(key);
listAddNodeTail(c->watched_keys,wk);
}unwatchAllKeys用来unwatch某个client所有watched keys
/* Unwatch all the keys watched by this client. To clean the EXEC dirty
* flag is up to the caller. */
/* unwatch某个client watch过的所有keys，主要操作:
* 1. 从db中watched_keys上相应key上的client列表中移除该client
* 2. 从该client的watched_keys中移除所有元素
*/
void unwatchAllKeys(redisClient *c) {
listIter li;
listNode *ln;
if (listLength(c->watched_keys) == 0) return;
listRewind(c->watched_keys,&li);
while((ln = listNext(&li))) {
list *clients;
watchedKey *wk;
/* Lookup the watched key -> clients list and remove the client
* from the list */
wk = listNodeValue(ln);
clients = dictFetchValue(wk->db->watched_keys, wk->key);
redisAssertWithInfo(c,NULL,clients != NULL);
listDelNode(clients,listSearchKey(clients,c));
/* Kill the entry at all if this was the only client */
if (listLength(clients) == 0)
dictDelete(wk->db->watched_keys, wk->key);
/* Remove this watched key from the client->watched list */
listDelNode(c->watched_keys,ln);
decrRefCount(wk->key);
zfree(wk);
}
}touchWatchedKey函数是保证原子性的一部分操作：
/* touchWatchedKey只会被signalModifiedKey调用，所以应该是某个key对应的value被改的时候会走到这里？
* 它只是简单地打标记，在执行EXEC命令时如果有这个标记，EXEC会直接失败。用于保证事务操作的原子性
*/
void touchWatchedKey(redisDb *db, robj *key) {
list *clients;
listIter li;
listNode *ln;
if (dictSize(db->watched_keys) == 0) return;
clients = dictFetchValue(db->watched_keys, key);
if (!clients) return;
/* Mark all the clients watching this key as REDIS_DIRTY_CAS */
/* Check if we are already watching for this key */
listRewind(clients,&li);
while((ln = listNext(&li))) {
redisClient *c = listNodeValue(ln);
c->flags |= REDIS_DIRTY_CAS;
}
}在将db的内容写到磁盘上时，会调用touchWatchedKeysOnFlush
/* On FLUSHDB or FLUSHALL all the watched keys that are present before the
* flush but will be deleted as effect of the flushing operation should
* be touched. "dbid" is the DB that's getting the flush. -1 if it is
* a FLUSHALL operation (all the DBs flushed). */
void touchWatchedKeysOnFlush(int dbid) {
listIter li1, li2;
listNode *ln;
/* For every client, check all the waited keys */
listRewind(server.clients,&li1);
while((ln = listNext(&li1))) {
redisClient *c = listNodeValue(ln);
listRewind(c->watched_keys,&li2);
while((ln = listNext(&li2))) {
watchedKey *wk = listNodeValue(ln);
/* For every watched key matching the specified DB, if the
* key exists, mark the client as dirty, as the key will be
* removed. */
if (dbid == -1 || wk->db->id == dbid) {
if (dictFind(wk->db->dict, wk->key->ptr) != NULL)
c->flags |= REDIS_DIRTY_CAS;
}
}
}
}最后，watch/unwatch命令的入口
/* watch命令的入口函数 */
void watchCommand(redisClient *c) {
int j;
if (c->flags & REDIS_MULTI) {
addReplyError(c,"WATCH inside MULTI is not allowed");
return;
}
for (j = 1; j < c->argc; j++)
watchForKey(c,c->argv[j]);
addReply(c,shared.ok);
}
/* unwatch命令的入口函数 */
void unwatchCommand(redisClient *c) {
unwatchAllKeys(c);
c->flags &= (~REDIS_DIRTY_CAS);
addReply(c,shared.ok);
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
