charles@charles-Aspire-4741:~/mydir/mylib/redis$ ./src/redis-cli
127.0.0.1:6379> lpush list hello
(integer) 1
127.0.0.1:6379> brpop list 0
1) "list"
2) "hello"
127.0.0.1:6379> brpop list 0
//阻塞在這里
/* ---------------------------------------------------- */
//當(dāng)我在另一個(gè)客戶端lpush一個(gè)元素之后，客戶端輸出為
127.0.0.1:6379> brpop list 0
1) "list"
2) "world"
(50.60s)//阻塞的時(shí)間

//阻塞狀態(tài)
typedef struct blockingState {
 /* Generic fields. */
 mstime_t timeout;  /* 超時(shí)時(shí)間 */
 /* REDIS_BLOCK_LIST */
 dict *keys;    /* The keys we are waiting to terminate a blocking
        * operation such as BLPOP. Otherwise NULL. */
 robj *target;   /* The key that should receive the element,
        * for BRPOPLPUSH. */
 /* REDIS_BLOCK_WAIT */
 int numreplicas;  /* Number of replicas we are waiting for ACK. */
 long long reploffset; /* Replication offset to reach. */
} blockingState;
//繼續(xù)列表
typedef struct readyList {
 redisDb *db;//就緒鍵所在的數(shù)據(jù)庫(kù)
 robj *key;//就緒鍵
} readyList;
//客戶端有關(guān)屬性
typedef struct redisClient {
 int btype;    /* Type of blocking op if REDIS_BLOCKED. */
 blockingState bpop;  /* blocking state */
}
//服務(wù)器有關(guān)屬性
struct redisServer {
  /* Blocked clients */
 unsigned int bpop_blocked_clients; /* Number of clients blocked by lists */
 list *unblocked_clients; /* list of clients to unblock before next loop */
 list *ready_keys;  /* List of readyList structures for BLPOP & co */
}
//數(shù)據(jù)庫(kù)有關(guān)屬性
typedef struct redisDb {
  //keys->redisCLient映射
  dict *blocking_keys;  /* Keys with clients waiting for data (BLPOP) */
 dict *ready_keys;   /* Blocked keys that received a PUSH */
}redisDB

void brpopCommand(redisClient *c) {
 blockingPopGenericCommand(c,REDIS_TAIL);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
void blockingPopGenericCommand(redisClient *c, int where) {
 robj *o;
 mstime_t timeout;
 int j;
 if (getTimeoutFromObjectOrReply(c,c->argv[c->argc-1],&timeout,UNIT_SECONDS)
  != REDIS_OK) return;//將超時(shí)時(shí)間保存在timeout中
 for (j = 1; j < c->argc-1; j++) {
  o = lookupKeyWrite(c->db,c->argv[j]);//在數(shù)據(jù)庫(kù)中查找操作的鏈表
  if (o != NULL) {//如果不為空
   if (o->type != REDIS_LIST) {//不是鏈表類(lèi)型
    addReply(c,shared.wrongtypeerr);//報(bào)錯(cuò)
    return;
   } else {
    if (listTypeLength(o) != 0) {//鏈表不為空
     /* Non empty list, this is like a non normal [LR]POP. */
     char *event = (where == REDIS_HEAD) ? "lpop" : "rpop";
     robj *value = listTypePop(o,where);//從鏈表中pop出一個(gè)元素
     redisAssert(value != NULL);
     //給客戶端發(fā)送pop出來(lái)的元素信息
     addReplyMultiBulkLen(c,2);
     addReplyBulk(c,c->argv[j]);
     addReplyBulk(c,value);
     decrRefCount(value);
     notifyKeyspaceEvent(REDIS_NOTIFY_LIST,event,
          c->argv[j],c->db->id);
     if (listTypeLength(o) == 0) {//如果鏈表為空，從數(shù)據(jù)庫(kù)刪除鏈表
      dbDelete(c->db,c->argv[j]);
      notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,"del",
           c->argv[j],c->db->id);
     }
     /* 省略一部分 */
    }
   }
  }
 }
  /* 如果鏈表為空，則阻塞客戶端 */
  blockForKeys(c, c->argv + 1, c->argc - 2, timeout, NULL);
}

void blockForKeys(redisClient *c, robj **keys, int numkeys, mstime_t timeout, robj *target) {
 dictEntry *de;
 list *l;
 int j;
 c->bpop.timeout = timeout;//超時(shí)時(shí)間賦值給客戶端blockingState屬性
 c->bpop.target = target;//這屬性適用于brpoplpush命令的輸入對(duì)象，如果是brpop, //則target為空
 if (target != NULL) incrRefCount(target);//不為空，增加引用計(jì)數(shù)
 for (j = 0; j < numkeys; j++) {
  /* 將阻塞的key存入c.bpop.keys字典中 */
  if (dictAdd(c->bpop.keys,keys[j],NULL) != DICT_OK) continue;
  incrRefCount(keys[j]);
  /* And in the other "side", to map keys -> clients */
  //將阻塞的key和客戶端添加進(jìn)c->db->blocking_keys
  de = dictFind(c->db->blocking_keys,keys[j]);
  if (de == NULL) {
   int retval;
   /* For every key we take a list of clients blocked for it */
   l = listCreate();
   retval = dictAdd(c->db->blocking_keys,keys[j],l);
   incrRefCount(keys[j]);
   redisAssertWithInfo(c,keys[j],retval == DICT_OK);
  } else {
   l = dictGetVal(de);
  }
  listAddNodeTail(l,c);//添加到阻塞鍵的客戶點(diǎn)鏈表中
 }
 blockClient(c,REDIS_BLOCKED_LIST);//設(shè)置客戶端阻塞標(biāo)志
}

void blockClient(redisClient *c, int btype) {
 c->flags |= REDIS_BLOCKED;//設(shè)置標(biāo)志
 c->btype = btype;//阻塞操作類(lèi)型
 server.bpop_blocked_clients++;
}

if (listLength(server.ready_keys))
   handleClientsBlockedOnLists();

//db.c
void dbAdd(redisDb *db, robj *key, robj *val) {
 sds copy = sdsdup(key->ptr);
 int retval = dictAdd(db->dict, copy, val);//將數(shù)據(jù)添加進(jìn)數(shù)據(jù)庫(kù)
 redisAssertWithInfo(NULL,key,retval == REDIS_OK);
 //判斷是否為鏈表類(lèi)型，如果是，調(diào)用有鏈表已經(jīng)ready函數(shù)
 if (val->type == REDIS_LIST) signalListAsReady(db, key);
 if (server.cluster_enabled) slotToKeyAdd(key);
 }
//t_list.c
void signalListAsReady(redisDb *db, robj *key) {
 readyList *rl;
 /* 沒(méi)有客戶端阻塞在這個(gè)鍵上，則直接返回. */
 if (dictFind(db->blocking_keys,key) == NULL) return;
 /* 這個(gè)鍵已近被喚醒了，所以沒(méi)必要重新入隊(duì) */
 if (dictFind(db->ready_keys,key) != NULL) return;
 /* Ok, 除了上述兩情況，把這個(gè)鍵放入server.ready_keys */
 rl = zmalloc(sizeof(*rl));
 rl->key = key;
 rl->db = db;
 incrRefCount(key);
 listAddNodeTail(server.ready_keys,rl);//添加鏈表末尾
 /* We also add the key in the db->ready_keys dictionary in order
  * to avoid adding it multiple times into a list with a simple O(1)
  * check. */
 incrRefCount(key);
 //同時(shí)將這個(gè)阻塞鍵放入db->ready_keys
 redisAssert(dictAdd(db->ready_keys,key,NULL) == DICT_OK);
}

void handleClientsBlockedOnLists(void) {
 while(listLength(server.ready_keys) != 0) {
  list *l;
  /* 將server.ready_keys賦給一個(gè)新的list,再將server.ready_keys清空 */
  l = server.ready_keys;
  server.ready_keys = listCreate();
  /* 迭代每一個(gè)就緒的每一個(gè)readyList */
  while(listLength(l) != 0) {
   listNode *ln = listFirst(l);//獲取第一個(gè)就緒readyList
   readyList *rl = ln->value;
   /* 從rl所屬的數(shù)據(jù)庫(kù)中刪除rl */
   dictDelete(rl->db->ready_keys,rl->key);
   /* 查詢r(jià)l所屬的數(shù)據(jù)庫(kù)查找rl->key ,給阻塞客戶端回復(fù)rl->key鏈表中的第一個(gè)元素*/
   robj *o = lookupKeyWrite(rl->db,rl->key);
   if (o != NULL && o->type == REDIS_LIST) {
    dictEntry *de;
    /* 在rl->db->blocking_keys查找阻塞在rl->key的客戶端鏈表 */
    de = dictFind(rl->db->blocking_keys,rl->key);
    if (de) {
     list *clients = dictGetVal(de);//轉(zhuǎn)換為客戶端鏈表
     int numclients = listLength(clients);
     while(numclients--) {//給每個(gè)客戶端發(fā)送消息
      listNode *clientnode = listFirst(clients);
      redisClient *receiver = clientnode->value;//阻塞的客戶端
      robj *dstkey = receiver->bpop.target;//brpoplpush命令目的鏈表
      int where = (receiver->lastcmd &&
          receiver->lastcmd->proc == blpopCommand) ?
         REDIS_HEAD : REDIS_TAIL;//獲取取出的方向
      robj *value = listTypePop(o,where);//取出就緒鏈表的元素
      if (value) {
       /* Protect receiver->bpop.target, that will be
        * freed by the next unblockClient()
        * call. */
       if (dstkey) incrRefCount(dstkey);
       unblockClient(receiver);//設(shè)置客戶端為非阻塞狀態(tài)
       if (serveClientBlockedOnList(receiver,
        rl->key,dstkey,rl->db,value,
        where) == REDIS_ERR)
       {
        /* If we failed serving the client we need
         * to also undo the POP operation. */
         listTypePush(o,value,where);
       }//給客戶端回復(fù)鏈表中的元素內(nèi)容
       if (dstkey) decrRefCount(dstkey);
       decrRefCount(value);
      } else {
       break;
      }
     }
    }
    //如果鏈表為空，則從數(shù)據(jù)庫(kù)中刪除
    if (listTypeLength(o) == 0) dbDelete(rl->db,rl->key);
    /* We don't call signalModifiedKey() as it was already called
     * when an element was pushed on the list. */
   }
   /* 回收rl */
   decrRefCount(rl->key);
   zfree(rl);
   listDelNode(l,ln);
  }
  listRelease(l); /* We have the new list on place at this point. */
 }
}

int serveClientBlockedOnList(redisClient *receiver, robj *key, robj *dstkey, redisDb *db, robj *value, int where)
{
 robj *argv[3];
 if (dstkey == NULL) {
  /* Propagate the [LR]POP operation. */
  argv[0] = (where == REDIS_HEAD) ? shared.lpop :
           shared.rpop;
  argv[1] = key;
  propagate((where == REDIS_HEAD) ?
   server.lpopCommand : server.rpopCommand,
   db->id,argv,2,REDIS_PROPAGATE_AOF|REDIS_PROPAGATE_REPL);
  /* BRPOP/BLPOP */
  addReplyMultiBulkLen(receiver,2);
  addReplyBulk(receiver,key);
  addReplyBulk(receiver,value);
 } else {
  /* BRPOPLPUSH */
   /* 省略 */
 }
}

int clientsCronHandleTimeout(redisClient *c, mstime_t now_ms) {
 time_t now = now_ms/1000;
 //..........
 else if (c->flags & REDIS_BLOCKED) {
  /* Blocked OPS timeout is handled with milliseconds resolution.
   * However note that the actual resolution is limited by
   * server.hz. */
  if (c->bpop.timeout != 0 && c->bpop.timeout < now_ms) {
   /* Handle blocking operation specific timeout. */
   replyToBlockedClientTimedOut(c);
   unblockClient(c);
  }
 }
 //.............