diff --git a/lib_acl_cpp/include/acl_cpp/redis/redis_client.hpp b/lib_acl_cpp/include/acl_cpp/redis/redis_client.hpp
index 6dec14919..26dd4f5bd 100644
--- a/lib_acl_cpp/include/acl_cpp/redis/redis_client.hpp
+++ b/lib_acl_cpp/include/acl_cpp/redis/redis_client.hpp
@@ -55,7 +55,8 @@ public:
 	int get_strings(std::vector<string>& result);
 	int get_strings(std::vector<string>* result);
 	int get_strings(std::map<string, string>& result);
-	int get_strings(std::vector<string>& names, std::vector<string>& values);
+	int get_strings(std::vector<string>& names,
+		std::vector<string>& values);
 	int get_strings(std::vector<const char*>& names,
 		std::vector<const char*>& values);
 
diff --git a/lib_acl_cpp/include/acl_cpp/redis/redis_hyperloglog.hpp b/lib_acl_cpp/include/acl_cpp/redis/redis_hyperloglog.hpp
index f5e94a9e2..ae5b206f9 100644
--- a/lib_acl_cpp/include/acl_cpp/redis/redis_hyperloglog.hpp
+++ b/lib_acl_cpp/include/acl_cpp/redis/redis_hyperloglog.hpp
@@ -15,14 +15,36 @@ public:
 	redis_hyperloglog(redis_client* conn = NULL);
 	~redis_hyperloglog();
 
+	/**
+	 * 将任意数量的元素添加到指定的 HyperLogLog 里面
+	 * @param key {const char*} 指定 key 值
+	 * @param first_element {const char*} 元素集合的第一个元素值，非空字符串
+	 * @return {int} 操作是否成功，同时表明是否发生了变更，返回值含义如下：
+	 *  1：操作成功，且数据发生了变更（新增数据或老数据发生变更）
+	 *  0：修改老数据未发生变化
+	 * -1：出错或对应的 key 对象非 hyperloglog 对象
+	 */
 	int pfadd(const char* key, const char* first_element, ...);
 	int pfadd(const char* key, const std::vector<const char*>& elements);
 	int pfadd(const char* key, const std::vector<string>& elements);
 
+	/**
+	 * 获得给定键列表的 HyperLoglog 去重后元素的近似数量
+	 * @param first_key {const char*} key 集合的第一个 key，非空字符串
+	 * @return {int} 键列表集合中经去重后元素的近似数量
+	 */
 	int pfcount(const char* first_key, ...);
 	int pfcount(const std::vector<const char*>& keys);
 	int pfcount(const std::vector<string>& keys);
 
+	/**
+	 * 将多个 HyperLogLog 合并（merge）为一个 HyperLogLog ， 合并后的
+	 * HyperLogLog 的基数接近于所有输入 HyperLogLog 的可见集合的并集
+	 * @param dst {const char*} 目标存储 HyperLogLog 对象的键值
+	 * @param first_src {const char*} 源对象集合中第一个源 HyperLogLog 对象的键
+	 * @return {bool} 操作是否成功，返回 false 表明出错或目标/源对象非
+	 *  HyperLogLog 对象
+	 */
 	bool pfmerge(const char* dst, const char* first_src, ...);
 	bool pfmerge(const char* dst, const std::vector<const char*>& keys);
 	bool pfmerge(const char* dst, const std::vector<string>& keys);
diff --git a/lib_acl_cpp/include/acl_cpp/redis/redis_list.hpp b/lib_acl_cpp/include/acl_cpp/redis/redis_list.hpp
index 606eb3757..87641aa92 100644
--- a/lib_acl_cpp/include/acl_cpp/redis/redis_list.hpp
+++ b/lib_acl_cpp/include/acl_cpp/redis/redis_list.hpp
@@ -15,43 +15,21 @@ public:
 
 	/////////////////////////////////////////////////////////////////////
 
-	int llen(const char* key);
-	bool lindex(const char* key, size_t idx, string& buf,
-		bool* exist = NULL);
-	bool lset(const char* key, size_t idx, const char* value);
-	bool lset(const char* key, size_t idx, const char* value, size_t len);
-
-	int linsert_before(const char* key, const char* pivot,
-		const char* value);
-	int linsert_before(const char* key, const char* pivot,
-		size_t pivot_len, const char* value, size_t value_len);
-	int linsert_after(const char* key, const char* pivot,
-		const char* value);
-	int linsert_after(const char* key, const char* pivot,
-		size_t pivot_len, const char* value, size_t value_len);
-
-	int lpush(const char* key, const char* first_value, ...);
-	int lpush(const char* key, const char* values[], size_t argc);
-	int lpush(const char* key, const std::vector<string>& values);
-	int lpush(const char* key, const std::vector<const char*>& values);
-	int lpush(const char* key, const char* values[], size_t lens[],
-		size_t argc);
-
-	int rpush(const char* key, const char* first_value, ...);
-	int rpush(const char* key, const char* values[], size_t argc);
-	int rpush(const char* key, const std::vector<string>& values);
-	int rpush(const char* key, const std::vector<const char*>& values);
-	int rpush(const char* key, const char* values[], size_t lens[],
-		size_t argc);
-
-	int lpushx(const char* key, const char* value);
-	int lpushx(const char* key, const char* value, size_t len);
-	int rpushx(const char* key, const char* value);
-	int rpushx(const char* key, const char* value, size_t len);
-
-	int lpop(const char* key, string& buf);
-	int rpop(const char* key, string& buf);
+	/**
+	 * 从 key 列表对象中弹出一个元素对象（name/value对），采用阻塞方式从头部弹出；
+	 * 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个
+	 * 非空列表的头元素
+	 * @param result {std::pair<string, string>&} 存储结果元素对象，该对象的
+	 *  第一个字符串表示是列表对象的 key，第二个为该对象的头部元素
+	 * @param timeout {size_t} 等待阻塞时间（秒），在超时时间内没有获得元素对象，
+	 *  则返回 false；如果该值为 0 则一直等待至获得元素对象或出错
+	 * @param first_key {const char*} 第一个非空字符串的 key 键
+	 * @return {bool} 是否获得了头部元素对象，如果返回 false 则有以下可能原因：
+	 *  1、出错
+	 *  2、有一个 key 非列表对象
+	 *  3、key 不存在或超时未获得元素对象
 
+	 */
 	bool blpop(std::pair<string, string>& result, size_t timeout,
 		const char* first_key, ...);
 	bool blpop(const std::vector<const char*>& keys, size_t timeout,
@@ -59,6 +37,10 @@ public:
 	bool blpop(const std::vector<string>& keys, size_t timeout,
 		std::pair<string, string>& result);
 
+	/**
+	 * 含义参见 blpop，唯一区别为该方法弹出尾部元素对象
+	 * @sess blpop
+	 */
 	bool brpop(std::pair<string, string>& result, size_t timeout,
 		const char* first_key, ...);
 	bool brpop(const std::vector<const char*>& keys, size_t timeout,
@@ -66,17 +48,205 @@ public:
 	bool brpop(const std::vector<string>& keys, size_t timeout,
 		std::pair<string, string>& result);
 
-	bool rpoplpush(const char* src, const char* dst, string* buf = NULL);
+	/**
+	 * 阻塞式执行以下两个动作：
+	 * 1) 将列表 src 中的最后一个元素(尾元素)弹出，并返回给客户端。
+	 * 2) 将 src 弹出的元素插入到列表 dst ，作为 dst 列表的的头元素
+	 * @param src {const char*} 源列表对象 key
+	 * @param dst {const char*} 目标列表对象 key
+	 * @param buf {string*} 非空时存储 src 的尾部元素 key 值
+	 * @param timeout {size_t} 等待超时时间，如果为 0 则一直等待直到有数据或出错
+	 * @return {bool} 当从 src 列表中成功弹出尾部元素并放入 dst 列表头部后
+	 *  该方法返回 true；返回 false 表示超时、出错或 src/dst 有一个非列表对象
+	 * @see rpoplpush
+	 */
 	bool brpoplpush(const char* src, const char* dst, size_t timeout,
 		string* buf = NULL);
 
-	bool lrange(const char* key, size_t start, size_t end,
+	/**
+	 * 返回 key 对应的列表对象中，指定下标的元素
+	 * @param key {const char*} 列表对象的 key
+	 * @param idx {size_t} 下标值
+	 * @param buf {string&} 存储结果
+	 * @return {bool} 返回 true 表明操作成功，此时若 buf 数据非空则表明正确获得了
+	 *  指定下标的元素，如果 buf.empty()表示没有获得元素；返回 false 时表明操作失败
+	 */
+	bool lindex(const char* key, size_t idx, string& buf);
+
+	/**
+	 * 在列表对象中将一个新元素添加至指定元素的前面
+	 * @param key {const char*} 列表对象的 key
+	 * @param pivot {const char*} 列表对象中的一个指定元素名
+	 * @param value {const char*} 新的元素名
+	 * @reutrn {int} 返回该列表对象的元素个数，含义如下：
+	 *  -1 -- 表示出错或 key 非列表对象
+	 *  >0 -- 当前列表对象的元素个数
+	 */
+	int linsert_before(const char* key, const char* pivot,
+		const char* value);
+	int linsert_before(const char* key, const char* pivot,
+		size_t pivot_len, const char* value, size_t value_len);
+
+	/**
+	 * 在列表对象中将一个新元素添加至指定元素的后面
+	 * @param key {const char*} 列表对象的 key
+	 * @param pivot {const char*} 列表对象中的一个指定元素名
+	 * @param value {const char*} 新的元素名
+	 * @reutrn {int} 返回该列表对象的元素个数，含义如下：
+	 *  -1 -- 表示出错或 key 非列表对象
+	 *  >0 -- 当前列表对象的元素个数
+	 */
+	int linsert_after(const char* key, const char* pivot,
+		const char* value);
+	int linsert_after(const char* key, const char* pivot,
+		size_t pivot_len, const char* value, size_t value_len);
+
+	/**
+	 * 返回指定列表对象的元素个数
+	 * @param key {const char*} 列表对象的 key
+	 * @return {int} 返回指定列表对象的长度（即元素个数），
+	 */
+	int llen(const char* key);
+
+	/**
+	 * 从列表对象中移除并返回头部元素
+	 * @param key {const char*} 元素对象的 key
+	 * @param buf {string&} 存储弹出的元素值
+	 * @return {int} 返回值含义：1 -- 表示成功弹出一个元素，-1 -- 表示出错，或该
+	 *  对象非列表对象，或该对象已经为空
+	 */
+	int lpop(const char* key, string& buf);
+
+	/**
+	 * 将一个或多个值元素插入到列表对象 key 的表头
+	 * @param key {const char*} 列表对象的 key
+	 * @param first_value {const char*} 第一个非空字符串，该变参的列表的最后一个
+	 *  必须设为 NULL
+	 * @return {int} 返回添加完后当前列表对象中的元素个数，返回 -1 表示出错或该 key
+	 *  对象非列表对象，当该 key 不存在时会添加新的列表对象及对象中的元素
+	 */
+	int lpush(const char* key, const char* first_value, ...);
+	int lpush(const char* key, const char* values[], size_t argc);
+	int lpush(const char* key, const std::vector<string>& values);
+	int lpush(const char* key, const std::vector<const char*>& values);
+	int lpush(const char* key, const char* values[], size_t lens[],
+		size_t argc);
+
+	/**
+	* 将一个新的列表对象的元素添加至已经存在的指定列表对象的头部，当该列表对象
+	* 不存在时则不添加
+	 * @param key {const char*} 列表对象的 key
+	 * @param value {const char*} 新加的列表对象的元素
+	 * @return {int} 返回当前列表对象的元素个数，含义如下：
+	 *  -1：出错，或该 key 非列表对象
+	 *   0：该 key 对象不存在
+	 *  >0：添加完后当前列表对象中的元素个数
+	 */
+	int lpushx(const char* key, const char* value);
+	int lpushx(const char* key, const char* value, size_t len);
+
+	/**
+	 * 返回列表 key 中指定区间内（闭区间）的元素，区间以偏移量 start 和 end 指定；
+	 * 下标起始值从 0 开始，-1 表示最后一个下标值
+	 * @param key {const char*} 列表对象的 key
+	 * @param start {int} 起始下标值
+	 * @param end {int} 结束下标值
+	 * @param result {std::vector<string>&} 存储列表对象中指定区间的元素集合
+	 * @return {bool} 操作是否成功，当返回 false 表示出错或 key 非列表对象
+	 *  举例：
+	 *  1) 当 start = 0, end = 10 时则指定从下标 0 开始至 10 的 11 个元素
+	 *  2) 当 start = -1, end = -2 时则指定从最后一个元素第倒数第二个共 2 个元素 
+	 */
+	bool lrange(const char* key, int start, int end,
 		std::vector<string>& result);
 
+	/**
+	 * 根据元素值从列表对象中移除指定数量的元素
+	 * @param key {const char*} 列表对象的 key
+	 * @param count {int} 移除元素的数量限制，count 的含义如下：
+	 *  count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count
+	 *  count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值
+	 *  count = 0 : 移除表中所有与 value 相等的值
+	 * @param value {const char*} 指定的元素值，需要从列表对象中遍历所有与该值比较
+	 * @return {int} 被移除的对象数量，返回值含义如下：
+	 *  -1：出错或该 key 对象非列表对象
+	 *   0：key 不存在或移除的元素个数为 0
+	 *  >0：被成功移除的元素数量
+	 */
 	int lrem(const char* key, int count, const char* value);
 	int lrem(const char* key, int count, const char* value, size_t len);
 
-	bool ltrim(const char* key, size_t start, size_t end);
+	/**
+	 * 将列表 key 下标为 idx 的元素的值设置为 value，当 idx 参数超出范围，或对
+	 * 一个空列表( key 不存在)进行 lset 时，返回一个错误
+	 * @param key {const char*} 列表对象的 key
+	 * @param idx {int} 下标位置，当为负值时则从尾部向头尾部定位，否则采用顺序方式；
+	 *  如：0 表示头部第一个元素，-1 表示尾部开始的第一个元素
+	 * @param value {const char*} 元素新值
+	 * @return {bool} 当 key 非列表对象或 key 不存在或 idx 超出范围则返回 false
+	 */
+	bool lset(const char* key, int idx, const char* value);
+	bool lset(const char* key, int idx, const char* value, size_t len);
+
+	/**
+	 * 对指定的列表对象，根据限定区间范围进行删除；区间以偏移量 start 和 end 指定；
+	 * 下标起始值从 0 开始，-1 表示最后一个下标值
+	 * @param key {const char*} 列表对象的 key
+	 * @param start {int} 起始下标值
+	 * @param end {int} 结束下标值
+	 * @return {bool} 操作是否成功，当返回 false 时表示出错或指定的 key 对象非
+	 *  列表对象；当成功删除或 key 对象不存在时则返回 true
+	 */
+	bool ltrim(const char* key, int start, int end);
+
+	/**
+	 * 从列表对象中移除并返回尾部元素
+	 * @param key {const char*} 元素对象的 key
+	 * @param buf {string&} 存储弹出的元素值
+	 * @return {int} 返回值含义：1 -- 表示成功弹出一个元素，-1 -- 表示出错，或该
+	 *  对象非列表对象，或该对象已经为空
+	 */
+	int rpop(const char* key, string& buf);
+
+	/**
+	 * 在一个原子时间内，非阻塞方式执行以下两个动作：
+	 * 将列表 src 中的最后一个元素(尾元素)弹出，并返回给客户端。
+	 * 将 src 弹出的元素插入到列表 dst ，作为 dst 列表的的头元素
+	 * @param src {const char*} 源列表对象 key
+	 * @param dst {const char*} 目标列表对象 key
+	 * @param buf {string*} 非空时存储 src 的尾部元素 key 值
+	 * @return {bool} 当从 src 列表中成功弹出尾部元素并放入 dst 列表头部后
+	 *  该方法返回 true；返回 false 出错或 src/dst 有一个非列表对象
+	 */
+	bool rpoplpush(const char* src, const char* dst, string* buf = NULL);
+
+	/**
+	 * 将一个或多个值元素插入到列表对象 key 的表尾
+	 * @param key {const char*} 列表对象的 key
+	 * @param first_value {const char*} 第一个非空字符串，该变参的列表的最后一个
+	 *  必须设为 NULL
+	 * @return {int} 返回添加完后当前列表对象中的元素个数，返回 -1 表示出错或该 key
+	 *  对象非列表对象，当该 key 不存在时会添加新的列表对象及对象中的元素
+	 */
+	int rpush(const char* key, const char* first_value, ...);
+	int rpush(const char* key, const char* values[], size_t argc);
+	int rpush(const char* key, const std::vector<string>& values);
+	int rpush(const char* key, const std::vector<const char*>& values);
+	int rpush(const char* key, const char* values[], size_t lens[],
+		size_t argc);
+
+	/**
+	 * 将一个新的列表对象的元素添加至已经存在的指定列表对象的尾部，当该列表对象
+	 * 不存在时则不添加
+	 * @param key {const char*} 列表对象的 key
+	 * @param value {const char*} 新加的列表对象的元素
+	 * @return {int} 返回当前列表对象的元素个数，含义如下：
+	 *  -1：出错，或该 key 非列表对象
+	 *   0：该 key 对象不存在
+	 *  >0：添加完后当前列表对象中的元素个数
+	 */
+	int rpushx(const char* key, const char* value);
+	int rpushx(const char* key, const char* value, size_t len);
 
 private:
 	int linsert(const char* key, const char* pos, const char* pivot,
diff --git a/lib_acl_cpp/include/acl_cpp/redis/redis_pubsub.hpp b/lib_acl_cpp/include/acl_cpp/redis/redis_pubsub.hpp
index 9de1e538f..5c7e44b8f 100644
--- a/lib_acl_cpp/include/acl_cpp/redis/redis_pubsub.hpp
+++ b/lib_acl_cpp/include/acl_cpp/redis/redis_pubsub.hpp
@@ -20,32 +20,77 @@ public:
 	/////////////////////////////////////////////////////////////////////
 
 	/**
-	 *
+	 * 将信息发送到指定的频道 channel
+	 * @param channel {const char*} 所发送消息的目标频道
+	 * @param msg {const char*} 消息内容
+	 * @param len {size_t} 消息长度
 	 * @return {int} 成功发送至订阅该频道的订阅者数量
 	 *  -1：表示出错
-	 *  0：没有订阅者
-	 *  > 0：订阅该频道的订阅者数量
+	 *   0：没有订阅者
+	 *  >0：订阅该频道的订阅者数量
 	 */
 	int publish(const char* channel, const char* msg, size_t len);
 
+	/**
+	 * 订阅给定的一个或多个频道的信息；在调用本函数后的操作只能发送的命令有：
+	 * subscribe、unsubscribe、psubscribe、punsubscribe、get_message，只有
+	 * 取消订阅了所有频道（或连接重建）后才摆脱该限制
+	 * @param first_channel {const char*} 所订阅的频道列表的第一个非空字符串
+	 *  的频道，对于变参列表中的最后一个必须是 NULL
+	 * @return {int} 返回当前已经成功订阅的频道个数（即所订阅的所有频道数量）
+	 */
 	int subscribe(const char* first_channel, ...);
 	int subscribe(const std::vector<const char*>& channels);
 	int subscribe(const std::vector<string>& channels);
 
+	/**
+	 * 取消订阅给定的一个或多个频道的信息
+	 * @param first_channel {const char*} 所取消的所订阅频道列表的第一个频道
+	 * @return {int} 返回剩余的所订阅的频道的个数
+	 */
 	int unsubscribe(const char* first_channel, ...);
 	int unsubscribe(const std::vector<const char*>& channels);
 	int unsubscribe(const std::vector<string>& channels);
 
+	/**
+	* 订阅一个或多个符合给定模式的频道；每个模式以 * 作为匹配符；在调用本函数后的操作
+	* 只能发送的命令有：
+	* subscribe、unsubscribe、psubscribe、punsubscribe、get_message，只有
+	* 取消订阅了所有频道（或连接重建）后才摆脱该限制
+	 * @param first_pattern {const char*} 第一个匹配模式串
+	 * @return {int} 返回当前已经成功订阅的频道个数（即所订阅的所有频道数量）
+	 */
 	int psubscribe(const char* first_pattern, ...);
 	int psubscribe(const std::vector<const char*>& patterns);
 	int psubscribe(const std::vector<string>& patterns);
 
+	/**
+	 * 根据模式匹配串取消订阅给定的一个或多个频道的信息
+	 * @param first_pattern {const char*} 第一个匹配模式串
+	 * @return {int} 返回剩余的所订阅的频道的个数
+	 */
 	int punsubscribe(const char* first_pattern, ...);
 	int punsubscribe(const std::vector<const char*>& patterns);
 	int punsubscribe(const std::vector<string>& patterns);
 
+	/**
+	 * 在订阅频道后可以循环调用本函数从所订阅的频道中获取订阅消息；在调用 subscribe
+	 * 或 psubscribe 后才可调用本函数来获取所订阅的频道的消息
+	 * @param channel {string&} 存放当前有消息的频道名
+	 * @param msg {string&} 存放当前获得的消息内容
+	 * @return {bool} 是否成功，如果返回 false 则表示出错
+	 */
 	bool get_message(string& channel, string& msg);
 
+	/**
+	 * 列出当前的活跃频道：活跃频道指的是那些至少有一个订阅者的频道， 订阅模式的
+	 * 客户端不计算在内
+	 * @param channels {std::vector<string>&} 存放频道结果集
+	 * @param first_pattern {const char*} 作为附加的匹配模式第一个匹配字符串，
+	 *  该指针可以为 NULL，此时获取指所有的活跃频道；对于变参而言最后一个参数需为 NULL
+	 * @return {int} 返回活跃频道数； -1 表示出错
+	 *
+	 */
 	int pubsub_channels(std::vector<string>& channels,
 		const char* first_pattern, ...);
 	int pubsub_channels(const std::vector<const char*>& patterns,
@@ -53,6 +98,14 @@ public:
 	int pubsub_channels(const std::vector<string>& patterns,
 		std::vector<string>& channels);
 
+	/**
+	 * 返回给定频道的订阅者数量， 订阅模式的客户端不计算在内
+	 * @param out {std::map<string, int>&} 存储查询结果，其中 out->first 存放
+	 *  频道名，out->second 在座该频道的订阅者数量
+	 * @param first_pattern {const char*} 作为附加的匹配模式第一个匹配字符串，
+	 *  该指针可以为 NULL，此时获取指所有的活跃频道；对于变参而言最后一个参数需为 NULL
+	 * @return {int} 频道的数量，-1 表示出错
+	 */
 	int pubsub_numsub(std::map<string, int>& out,
 		const char* first_channel, ...);
 	int pubsub_numsub(const std::vector<const char*>& channels,
@@ -60,6 +113,11 @@ public:
 	int pubsub_numsub(const std::vector<string>& channels,
 		std::map<string, int>& out);
 
+	/**
+	 * 返回订阅模式的数量，这个命令返回的不是订阅模式的客户端的数量， 而是客户端订阅的
+	 * 所有模式的数量总和
+	 * @return {int} 客户端所有订阅模式的总和，-1 表示出错
+	 */
 	int pubsub_numpat();
 
 private:
diff --git a/lib_acl_cpp/include/acl_cpp/redis/redis_set.hpp b/lib_acl_cpp/include/acl_cpp/redis/redis_set.hpp
index f26fdf56f..7f5fd0700 100644
--- a/lib_acl_cpp/include/acl_cpp/redis/redis_set.hpp
+++ b/lib_acl_cpp/include/acl_cpp/redis/redis_set.hpp
@@ -17,6 +17,15 @@ public:
 
 	/////////////////////////////////////////////////////////////////////
 
+	/**
+	 * 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素
+	 * 将被忽略;
+	 * 1) 假如 key 不存在，则创建一个只包含 member 元素作成员的集合
+	 * 2) 当 key 不是集合类型时，返回一个错误
+	 * @param key {const char*} 集合对象的键
+	 * @param first_member {const char*} 第一个非 NULL 的成员
+	 * @return {int} 被添加到集合中的新元素的数量，不包括被忽略的元素
+	 */
 	int sadd(const char* key, const char* first_member, ...);
 	int sadd(const char* key, const std::vector<const char*>& memsbers);
 	int sadd(const char* key, const std::vector<string>& members);
@@ -24,58 +33,159 @@ public:
 	int sadd(const char* key, const char* argv[], const size_t lens[],
 		size_t argc);
 
+	/**
+	 * 从集合对象中随机移除并返回某个成员
+	 * @param key {const char*} 集合对象的键
+	 * @param buf {string&} 存储被移除的成员
+	 * @return {bool} 当 key 不存在或 key 是空集时返回 false
+	 */
 	bool spop(const char* key, string& buf);
+
+	/**
+	 * 获得集合对象中成员的数量
+	 * @param key {const char*} 集合对象的键
+	 * @return {int} 返回该集合对象中成员数量，含义如下：
+	 *  -1：出错或非集合对象
+	 *   0：成员数量为空或该 key 不存在
+	 *  >0：成员数量非空
+	 */
 	int scard(const char* key);
+
+	/**
+	 * 返回集合 key 中的所有成员
+	 * @param key {const char*} 集合对象的键值
+	 * @param members {std::vector<string>&} 存储结果集
+	 * @return {int} 结果集数量，返回 -1 表示出错或有一个 key 非集合对象
+	 */
 	int smembers(const char* key, std::vector<string>& members);
+
+	/**
+	 * 将 member 元素从 src 集合移动到 dst 集合
+	 * @param src {const char*} 源集合对象的键值
+	 * @param dst {const char*} 目标集合对象的键值
+	 * @param member {const char*} 源集合对象的成员
+	 * @return {int} 返回值含义如下：
+	 *  -1：出错或源/目标对象有一个非集合对象
+	 *   0：源对象不存在或成员在源对象中不存在
+	 *   1：成功从源对象中将一个成员移动至目标对象中
+	 */
 	int smove(const char* src, const char* dst, const char* member);
 	int smove(const char* src, const char* dst, const string& member);
 	int smove(const char* src, const char* dst,
 		const char* member, size_t len);
 
+	/**
+	 * 返回一个集合的全部成员，该集合是所有给定集合之间的差集
+	 * @param members {std::vector<string>&} 存储结果集
+	 * @param first_key {const char*} 第一个非空的集合对象 key
+	 * @return {int} 结果集数量，返回 -1 表示出错或有一个 key 非集合对象
+	 */
 	int sdiff(std::vector<string>& members, const char* first_key, ...);
 	int sdiff(const std::vector<const char*>& keys,
 		std::vector<string>& members);
 	int sdiff(const std::vector<string>& keys,
 		std::vector<string>& members);
 
+	/**
+	 * 返回一个集合的全部成员，该集合是所有给定集合的交集
+	 * @param members {std::vector<string>&} 存储结果集
+	 * @param first_key {const char*} 第一个集合对象 key（非NULL）
+	 * @return {int} 结果集数量，返回 -1 表示出错或有一个 key 非集合对象
+	 */
 	int sinter(std::vector<string>& members, const char* first_key, ...);
 	int sinter(const std::vector<const char*>& keys,
 		std::vector<string>& members);
 	int sinter(const std::vector<string>& keys,
 		std::vector<string>& members);
 
+	/**
+	 * 返回一个集合的全部成员，该集合是所有给定集合的并集
+	 * @param members {std::vector<string>&} 存储结果集
+	 * @param first_key {const char*} 第一个集合对象 key（非NULL）
+	 * @return {int} 结果集数量，返回 -1 表示出错或有一个 key 非集合对象
+	 */
 	int sunion(std::vector<string>& members, const char* first_key, ...);
 	int sunion(const std::vector<const char*>& keys,
 		std::vector<string>& members);
 	int sunion(const std::vector<string>& keys,
 		std::vector<string>& members);
 
+	/**
+	 * 这个命令的作用和 SDIFF 类似，但它将结果保存到 dst 集合，而不是简单地返回结果集
+	 * @param dst {const char*} 目标集合对象键值
+	 * @param first_key {const char*} 第一个非空的集合对象键值
+	 * @return {int} 结果集中的成员数量
+	 */
 	int sdiffstore(const char* dst, const char* first_key, ...);
 	int sdiffstore(const char* dst, const std::vector<const char*>& keys);
 	int sdiffstore(const char* dst, const std::vector<string>& keys);
 
+	/**
+	 * 这个命令类似于 SINTER 命令，但它将结果保存到 dst 集合，而不是简单地返回结果集
+	 * @param dst {const char*} 目标集合对象键值
+	 * @param first_key {const char*} 第一个非空的集合对象键值
+	 * @return {int} 结果集中的成员数量
+	 */
 	int sinterstore(const char* dst, const char* first_key, ...);
 	int sinterstore(const char* dst, const std::vector<const char*>& keys);
 	int sinterstore(const char* dst, const std::vector<string>& keys);
 
+	/**
+	 * 这个命令类似于 SUNION 命令，但它将结果保存到 dst 集合，而不是简单地返回结果集
+	 * @param dst {const char*} 目标集合对象键值
+	 * @param first_key {const char*} 第一个非空的集合对象键值
+	 * @return {int} 结果集中的成员数量
+	 */
 	int sunionstore(const char* dst, const char* first_key, ...);
 	int sunionstore(const char* dst, const std::vector<const char*>& keys);
 	int sunionstore(const char* dst, const std::vector<string>& keys);
 
+	/**
+	 * 判断 member 元素是否集合 key 的成员
+	 * @param key {const char*} 集合对象的键值
+	 * @param member {const char*} 集合对象中的一个成员元素
+	 * @return {bool} 返回 true 表示是，否则可能是因为不是或出错或该 key 对象
+	 *  非集合对象
+	 */
 	bool sismember(const char* key, const char* member);
 	bool sismember(const char* key, const char* member, size_t len);
 
+	/**
+	 * 如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素，如果还同时指定
+	 * 了元素个数，则会返回一个不超过该个数限制的结果集
+	 * @param key {const char*} 集合对象的键值
+	 * @param out 存储结果或结果集
+	 * @return {int} 结果的个数，为 -1 表示出错，0 表示没有成员
+	 */
 	int srandmember(const char* key, string& out);
 	int srandmember(const char* key, size_t n, std::vector<string>& out);
 
-	int srem(const char* key, const char* member);
-	int srem(const char* key, const char* member, size_t len);
+	/**
+	 * 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略
+	 * @param key {const char*} 集合对象的键值
+	 * @param first_member {const char*} 需要被移除的成员列表的第一个非 NULL成员，
+	 *  在变参的输入中需要将最后一个变参写 NULL
+	 * @retur {int} 被移除的成员元素的个数，当出错或非集合对象时返回 -1；当 key 不
+	 *  存在或成员不存在时返回 0
+	 */
 	int srem(const char* key, const char* first_member, ...);
 	int srem(const char* key, const std::vector<string>& members);
 	int srem(const char* key, const std::vector<const char*>& members);
 	int srem(const char* key, const char* members[],
 		size_t lens[], size_t argc);
 
+	/**
+	 * 命令用于迭代当前数据库中的数据库键
+	 * @param key {const char*} 哈希键值
+	 * @param cursor {int} 游标值，开始遍历时该值写 0
+	 * @param out {std::vector<string>&} 结果集
+	 * @param pattern {const char*} 匹配模式，glob 风格，非空时有效
+	 * @param count {const size_t*} 限定的结果集数量，非空指针时有效
+	 * @return {int} 下一个游标位置，含义如下：
+	 *   0：遍历结束
+	 *  -1: 出错
+	 *  >0: 游标的下一个位置
+	 */
 	int sscan(const char* key, int cursor, std::vector<string>& out,
 		const char* pattern = NULL, const size_t* count = NULL);
 };
diff --git a/lib_acl_cpp/include/acl_cpp/redis/redis_string.hpp b/lib_acl_cpp/include/acl_cpp/redis/redis_string.hpp
index 4d4dfcbc5..8244fbf9d 100644
--- a/lib_acl_cpp/include/acl_cpp/redis/redis_string.hpp
+++ b/lib_acl_cpp/include/acl_cpp/redis/redis_string.hpp
@@ -11,6 +11,9 @@ class string;
 class redis_client;
 class redis_result;
 
+/**
+ * 除 PSETEX 外所有的字符串对象的命令都已实现
+ */
 class ACL_CPP_API redis_string : public redis_command
 {
 public:
@@ -19,74 +22,203 @@ public:
 
 	/////////////////////////////////////////////////////////////////////
 
+	/**
+	 * 将字符串值 value 关联到 key
+	 * @param key {const char*} 字符串对象的 key
+	 * @param value {const char*} 字符串对象的 value
+	 * @return {bool} 操作是否成功，返回 false 表示出错或该 key 对象非字符串对象
+	 */
 	bool set(const char* key, const char* value);
 	bool set(const char* key, size_t key_len,
 		const char* value, size_t value_len);
 
+	/**
+	 * 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)，
+	 * 如果 key 已经存在， SETEX 命令将覆写旧值
+	 * @param key {const char*} 字符串对象的 key
+	 * @param value {const char*} 字符串对象的 value
+	 * @param timeout {int} 过期值，单位为秒
+	 * @return {bool} 操作是否成功，返回 false 表示出错或该 key 对象非字符串对象
+	 */
 	bool setex(const char* key, const char* value, int timeout);
 	bool setex(const char* key, size_t key_len, const char* value,
 		size_t value_len, int timeout);
 
+	/**
+	 * 将 key 的值设为 value ，当且仅当 key 不存在，若给定的 key 已经存在，
+	 * 则 SETNX 不做任何动作
+	 * @param key {const char*} 字符串对象的 key
+	 * @param value {const char*} 字符串对象的 value
+	 * @return {int} 返回值含义如下：
+	 *  -1：出错或 key 非字符串对象
+	 *   0：给定 key 的对象存在
+	 *   1：添加成功
+	 */
 	int setnx(const char* key, const char* value);
 	int setnx(const char* key, size_t key_len,
 		const char* value, size_t value_len);
 
+	/**
+	 * 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来
+	 * 的值的末尾；如果 key 不存在， APPEND 就简单地将给定 key 设为 value
+	 * @param key {const char*} 字符串对象的 key
+	 * @param value {const char*} 字符串对象的值
+	 * @return {int} 返回当前该字符串的长度，-1 表示出错或 key 非字符串对象
+	 */
 	int append(const char* key, const char* value);
 	int append(const char* key, const char* value, size_t size);
 
+	/**
+	 * 返回 key 所关联的字符串值
+	 * @param key {const char*} 字符串对象的 key
+	 * @param buf {string&} 操作成功后存储字符串对象的值
+	 * @return {bool} 操作是否成功，返回 false 表示出错或 key 非字符串对象
+	 */
 	bool get(const char* key, string& buf);
 	bool get(const char* key, size_t len, string& buf);
+
+	/**
+	 * 返回 key 所关联的字符串值，当返回的字符串值比较大时，内部会自动进行切片，即将
+	 * 一个大内存切成一些非连续的小内存，使用者需要根据返回的结果对象重新对结果数据进行
+	 * 组装，比如可以调用： redis_result::get(size_t, size_t*) 函数获得某个切
+	 * 片的片断数据，根据 redis_result::get_size() 获得分片数组的长度
+	 * @param key {const char*} 字符串对象的 key
+	 * @param buf {string&} 操作成功后存储字符串对象的值
+	 * @return {bool} 操作是否成功，返回 false 表示出错或 key 非字符串对象
+	 */
 	const redis_result* get(const char* key);
 	const redis_result* get(const char* key, size_t len);
 
+	/**
+	 * 将给定 key 的值设为 value ，并返回 key 的旧值，当 key 存在但不是
+	 * 字符串类型时，返回一个错误
+	 * @param key {const char*} 字符串对象的 key
+	 * @param value {const char*} 设定的新的对象的值
+	 * @param buf {string&} 存储对象的旧的值
+	 * @return {bool} 是否成功
+	 */
 	bool getset(const char* key, const char* value, string& buf);
-	bool getset(const char* key, size_t key_len,
-		const char* value, size_t value_len, string& buf);
+	bool getset(const char* key, size_t key_len, const char* value,
+		size_t value_len, string& buf);
 
 	/////////////////////////////////////////////////////////////////////
 
-	int str_len(const char* key);
-	int str_len(const char* key, size_t len);
+	/**
+	 * 获得指定 key 的字符串对象的值的数据长度
+	 * @param key {const char*} 字符串对象的 key
+	 * @return {int} 返回值含义如下：
+	 *  -1：出错或非字符串对象
+	 *   0：该 key 不存在
+	 *  >0：该字符串数据的长度
+	 */
+	int get_strlen(const char* key);
+	int get_strlen(const char* key, size_t len);
 
+	/**
+	 * 用 value 参数覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始，
+	 * 不存在的 key 当作空白字符串处理
+	 * @param key {const char*} 字符串对象的 key
+	 * @param offset {unsigned} 偏移量起始位置，该值可以大于字符串的数据长度，此时
+	 *  是间的空洞将由 \0 补充
+	 * @param value {const char*} 覆盖的值
+	 * @return {int} 当前字符串对象的数据长度
+	 */
 	int setrange(const char* key, unsigned offset, const char* value);
 	int setrange(const char* key, size_t key_len, unsigned offset,
 		const char* value, size_t value_len);
 
+	/**
+	 * 返回 key 中字符串值的子字符串，字符串的截取范围由 start 和 end 两个偏移量决定
+	 * (包括 start 和 end 在内)
+	 * @param key {const char*} 字符串对象的 key
+	 * @param start {int} 起始下标值
+	 * @param end {int} 结束下标值
+	 * @param buf {string&} 成功时存储结果
+	 * @return {bool} 操作是否成功
+	 *  注：下标位置可以为负值，表示从字符串尾部向前开始计数，如 -1 表示最后一个元素
+	 */
 	bool getrange(const char* key, int start, int end, string& buf);
 	bool getrange(const char* key, size_t key_len,
 		int start, int end, string& buf);
 
 	/////////////////////////////////////////////////////////////////////
 
-	bool setbit(const char* key, unsigned offset, int bit);
-	bool setbit(const char* key, size_t len, unsigned offset, int bit);
+	/**
+	 * 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)，
+	 * 位的设置或清除取决于 value 参数，可以是 0 也可以是 1
+	 * @param key {const char*} 字符串对象的 key
+	 * @param offset {unsigned} 指定偏移量的位置
+	 * @param bit {bool} 为 true 表示设置标志位，否则为取消标志位
+	 * @return {int} 操作成功后返回该位置原来的存储位的值，含义如下：
+	 *  -1：出错或该 key 非字符串对象
+	 *   0：原来的存储位为 0
+	 *   1：原来的存储位为 1
+	 */
+	bool setbit(const char* key, unsigned offset, bool bit);
+	bool setbit(const char* key, size_t len, unsigned offset, bool bit);
 
+	/**
+	 * 对 key 所储存的字符串值，获取指定偏移量上的位(bit)，当 offset 比字符串值
+	 * 的长度大，或者 key 不存在时，返回 0
+	 * @param key {const char*} 字符串对象的 key
+	 * @param offset {unsigned} 指定偏移量的位置
+	 * @param bit {int&} 成功后存储指定位置的标志位
+	 * @return {bool} 操作是否成功，返回 false 表示出错或该 key 非字符串对象
+	 */
 	bool getbit(const char* key, unsigned offset, int& bit);
 	bool getbit(const char* key, size_t len, unsigned offset, int& bit);
 
+	/**
+	 * 计算给定字符串中，被设置为 1 的比特位的数量，若指定了 start/end，则计数在指定
+	 * 区间内进行
+	 * @param key {const char*} 字符串对象的 key
+	 * @return {int} 标志位为 1 的数量，-1 表示出错或非字符串对象
+	 */
 	int bitcount(const char* key);
 	int bitcount(const char* key, size_t len);
 	int bitcount(const char* key, int start, int end);
 	int bitcount(const char* key, size_t len, int start, int end);
 
+	/**
+	 * 对一个或多个 key 求逻辑并，并将结果保存到 destkey
+	 * @param destkey {const char*} 目标字符串对象的 key
+	 * @param keys 源字符串对象集合
+	 * @return {int}
+	 */
 	int bitop_and(const char* destkey, const std::vector<string>& keys);
-	int bitop_or(const char* destkey, const std::vector<string>& keys);
-	int bitop_xor(const char* destkey, const std::vector<string>& keys);
-
 	int bitop_and(const char* destkey, const std::vector<const char*>& keys);
-	int bitop_or(const char* destkey, const std::vector<const char*>& keys);
-	int bitop_xor(const char* destkey, const std::vector<const char*>& keys);
-
 	int bitop_and(const char* destkey, const char* key, ...);
-	int bitop_or(const char* destkey, const char* key, ...);
-	int bitop_xor(const char* destkey, const char* key, ...);
-
 	int bitop_and(const char* destkey, const char* keys[], size_t size);
+
+	/**
+	 * 对一个或多个 key 求逻辑或，并将结果保存到 destkey
+	 * @param destkey {const char*} 目标字符串对象的 key
+	 * @param keys 源字符串对象集合
+	 * @return {int}
+	 */
+	int bitop_or(const char* destkey, const std::vector<string>& keys);
+	int bitop_or(const char* destkey, const std::vector<const char*>& keys);
+	int bitop_or(const char* destkey, const char* key, ...);
 	int bitop_or(const char* destkey, const char* keys[], size_t size);
+
+	/**
+	 * 对一个或多个 key 求逻辑异或，并将结果保存到 destkey
+	 * @param destkey {const char*} 目标字符串对象的 key
+	 * @param keys 源字符串对象集合
+	 * @return {int}
+	 */
+	int bitop_xor(const char* destkey, const std::vector<string>& keys);
+	int bitop_xor(const char* destkey, const std::vector<const char*>& keys);
+	int bitop_xor(const char* destkey, const char* key, ...);
 	int bitop_xor(const char* destkey, const char* keys[], size_t size);
 
 	/////////////////////////////////////////////////////////////////////
 
+	/**
+	 * 同时设置一个或多个 key-value 对
+	 * @param objs key-value 对集合
+	 * @return {bool} 操作是否成功
+	 */
 	bool mset(const std::map<string, string>& objs);
 	bool mset(const std::map<int, string>& objs);
 
@@ -101,6 +233,14 @@ public:
 
 	/////////////////////////////////////////////////////////////////////
 
+	/**
+	 * 当且仅当所有给定 key 都不存在时同时设置一个或多个 key-value 对
+	 * @param objs key-value 对集合
+	 * @return {int} 返回值含义如下：
+	 *  -1：出错或非字符串对象
+	 *   0：添加的 key 集合中至少有一个已经存在
+	 *   1：添加成功
+	 */
 	int msetnx(const std::map<string, string>& objs);
 	int msetnx(const std::map<int, string>& objs);
 
@@ -115,6 +255,14 @@ public:
 
 	/////////////////////////////////////////////////////////////////////
 
+	/**
+	 * 返回所有(一个或多个)给定 key 的值，如果给定的 key 里面，有某个 key 不存在，
+	 * 那么这个 key 返回空串添加进结果数组中
+	 * @param keys {const std::vector<string>&} 字符串 key 集合
+	 * @param out {std::vector<string>*} 非空时存储字符串值集合数组，对于不存在
+	 *  的 key 也会存储一个空串对象
+	 * @return {bool} 操作是否成功
+	 */
 	bool mget(const std::vector<string>& keys,
 		std::vector<string>* out = NULL);
 	bool mget(const std::vector<const char*>& keys,
@@ -131,26 +279,91 @@ public:
 	bool mget(const char* keys[], const size_t keys_len[], size_t argc,
 		std::vector<string>* out = NULL);
 
+	/** 
+	 * 在调用 mget 后调用此函数返回结果集数组的个数
+	 * @return {size_t}
+	 */
 	size_t mget_size() const;
+
+	/**
+	 * 返回指定下标位置的字符串数据，当下标越界或数据为空或为空串时返回 NULL
+	 * 可以先调用 mget_size() 获得数组长度
+	 * @param i {size_t} 下标位置
+	 * @param len {size*} 返回的数据非空时存储数据长度
+	 * @return {const char*} 返回的数据地址
+	 */
 	const char* mget_value(size_t i, size_t* len = NULL) const;
+
+	/**
+	 * 返回指定下标位置的结果对象，可以先调用 mget_size() 获得数组长度
+	 * @param i {size_t} 下标位置
+	 * @return {const redis_result*} 如果下标越界或数据错误则返回 NULL
+	 */
 	const redis_result* mget_child(size_t i) const;
 
 	/////////////////////////////////////////////////////////////////////
 
+	/**
+	 * 将 key 中储存的数字值增一
+	 * 1）如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作；
+	 * 2）如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误；
+	 * 3）本操作的值限制在 64 位(bit)有符号数字表示之内
+	 * @param key {const char*} 字符串对象的 key
+	 * @param result {long long int*} 非空时存储操作结果
+	 * @return {bool} 操作是否成功
+	 */
 	bool incr(const char* key, long long int* result = NULL);
+
+	/**
+	 * 将 key 所储存的值加上增量 increment
+	 * 1）如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令
+	 * 2）如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误
+	 * 3）本操作的值限制在 64 位(bit)有符号数字表示之内
+	 * @param key {const char*} 字符串对象的 key
+	 * @param inc {long long int} 增量值
+	 * @param result {long long int*} 非空时存储操作结果
+	 * @return {bool} 操作是否成功
+	 */
 	bool incrby(const char* key, long long int inc,
 		long long int* result = NULL);
+
+	/**
+	 * 为 key 中所储存的值加上浮点数增量
+	 * 1) 如果 key 不存在，那么 INCRBYFLOAT 会先将 key 的值设为 0 ，再执行加法操作
+	 * 2) 如果命令执行成功，那么 key 的值会被更新为（执行加法之后的）新值，并且新值会
+	 *    以字符串的形式返回给调用者
+	 * 3) 计算结果也最多只能表示小数点的后十七位
+	 * @param key {const char*} 字符串对象的 key
+	 * @param inc {double} 增量值
+	 * @param result {double*} 非空时存储操作结果
+	 * @return {bool} 操作是否成功
+	 */
 	bool incrbyfloat(const char* key, double inc, double* result = NULL);
 
+	/**
+	 * 将 key 中储存的数字值减一
+	 * 1) 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作
+	 * 2) 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误
+	 * 3) 本操作的值限制在 64 位(bit)有符号数字表示之内
+	 * @param key {const char*} 字符串对象的 key
+	 * @param result {long long int*} 非空时存储操作结果
+	 * @return {bool} 操作是否成功
+	 */
 	bool decr(const char* key, long long int* result = NULL);
+
+	/**
+	 * 将 key 所储存的值减去减量 decrement
+	 * 1) 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作
+	 * 2) 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误
+	 * 3) 本操作的值限制在 64 位(bit)有符号数字表示之内
+	 * @param key {const char*} 字符串对象的 key
+	 * @param dec {long long int} 减量值
+	 * @param result {long long int*} 非空时存储操作结果
+	 * @return {bool} 操作是否成功
+	 */
 	bool decrby(const char* key, long long int dec,
 		long long int* result = NULL);
 
-	bool incoper(const char* cmd, const char* key, long long int inc,
-		long long int* result);
-
-	/////////////////////////////////////////////////////////////////////
-
 private:
 	int bitop(const char* op, const char* destkey,
 		const std::vector<string>& keys);
@@ -158,6 +371,10 @@ private:
 		const std::vector<const char*>& keys);
 	int bitop(const char* op, const char* destkey,
 		const char* keys[], size_t size);
+
+	bool incoper(const char* cmd, const char* key, long long int inc,
+		long long int* result);
+
 };
 
 } // namespace acl
diff --git a/lib_acl_cpp/include/acl_cpp/redis/redis_transaction.hpp b/lib_acl_cpp/include/acl_cpp/redis/redis_transaction.hpp
index 3ba8e73ba..f65c76b07 100644
--- a/lib_acl_cpp/include/acl_cpp/redis/redis_transaction.hpp
+++ b/lib_acl_cpp/include/acl_cpp/redis/redis_transaction.hpp
@@ -18,15 +18,67 @@ public:
 
 	/////////////////////////////////////////////////////////////////////
 
+	/**
+	 * 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，
+	 * 那么事务将被打断
+	 * @param keys {const std::vector<string>&} key 集合
+	 * @return {bool} 操作是否成功，即使 key 集合中的有 key 不存在也会返回成功
+	 */
 	bool watch(const std::vector<string>& keys);
-	bool unwatch(const std::vector<string>& keys);
+
+	/**
+	 * 取消 WATCH 命令对所有 key 的监视
+	 * @return {bool} 操作是否成功
+	 */
+	bool unwatch();
+
+	/**
+	 * 标记一个事务块的开始，事务块内的多条命令会按照先后顺序被放进一个队列当中，
+	 * 最后由 EXEC 命令原子性(atomic)地执行
+	 * @return {bool} 操作是否成功
+	 */
 	bool multi();
+
+	/**
+	 * 执行所有事务块内的命令，假如某个(或某些) key 正处于 WATCH 命令的监视之下，
+	 * 且事务块中有和这个(或这些) key 相关的命令，那么 EXEC 命令只在这个(或这些)
+	 * key 没有被其他命令所改动的情况下执行并生效，否则该事务被打断(abort)；
+	 * 在执行本条命令成功后，可以调用下面的 get_size()/get_child() 获得每条命令的
+	 * 操作结果
+	 * @return {bool} 操作是否成功
+	 */
 	bool exec();
+
+	/**
+	 * 取消事务，放弃执行事务块内的所有命令，如果正在使用 WATCH 命令监视某个(或某些)
+	 * key，那么取消所有监视，等同于执行命令 UNWATCH
+	 */
 	bool discard();
+
+	/**
+	 * 在 multi 和 exec 之间执行多条 redis 客户端命令
+	 * @param cmd {const char*} redis 命令
+	 * @param argv {const char* []} 参数数组
+	 * @param lens [const size_t []} 参数的长度数组
+	 * @param argc {size_t} 参数数组的长度
+	 * @return {bool} 操作是否成功
+	 */
 	bool queue_cmd(const char* cmd, const char* argv[],
 		const size_t lens[], size_t argc);
 
+	/**
+	 * 在成功调用 exec 后调用本函数获得操作结果数组的长度
+	 * @return {size_t}
+	 */
 	size_t get_size() const;
+
+	/**
+	 * 获取指定下标的对应的命令的执行结果对象
+	 * @param i {size_t} 命令执行结果在结果数组中的下标
+	 * @param cmd {string*} 该参数非空时存放对应的 redis 命令
+	 * @return {const redis_result*} 执行的某条命令的结果对象，
+	 *  当 i 越界时返回 NULL
+	 */
 	const redis_result* get_child(size_t i, string* cmd) const;
 
 private:
diff --git a/lib_acl_cpp/samples/redis/redis_string/redis_string.cpp b/lib_acl_cpp/samples/redis/redis_string/redis_string.cpp
index 2a27a9dda..9bb062050 100644
--- a/lib_acl_cpp/samples/redis/redis_string/redis_string.cpp
+++ b/lib_acl_cpp/samples/redis/redis_string/redis_string.cpp
@@ -141,7 +141,7 @@ static void test_strlen(acl::redis_string& option, int n)
 		key.format("%s_%d", __keypre.c_str(), i);
 
 		option.reset();
-		int ret = option.str_len(key.c_str());
+		int ret = option.get_strlen(key.c_str());
 		if (ret < 0)
 		{
 			printf("str_len error, key: %s\r\n", key.c_str());
diff --git a/lib_acl_cpp/src/redis/redis_list.cpp b/lib_acl_cpp/src/redis/redis_list.cpp
index b105e25c0..81b696b7c 100644
--- a/lib_acl_cpp/src/redis/redis_list.cpp
+++ b/lib_acl_cpp/src/redis/redis_list.cpp
@@ -39,12 +39,8 @@ int redis_list::llen(const char* key)
 	return conn_->get_number();
 }
 
-bool redis_list::lindex(const char* key, size_t idx,
-	string& buf, bool* exist /*  = NULL */)
+bool redis_list::lindex(const char* key, size_t idx, string& buf)
 {
-	if (exist)
-		*exist = false;
-
 	const char* argv[3];
 	size_t lens[3];
 
@@ -59,19 +55,15 @@ bool redis_list::lindex(const char* key, size_t idx,
 	lens[2] = strlen(tmp);
 
 	conn_->build_request(3, argv, lens);
-	long ret = conn_->get_string(buf);
-	if (exist && ret > 0)
-		*exist = true;
-	return ret >= 0 ? true : false;
+	return conn_->get_string(buf) >= 0 ? true : false;
 }
 
-bool redis_list::lset(const char* key, size_t idx, const char* value)
+bool redis_list::lset(const char* key, int idx, const char* value)
 {
 	return lset(key, idx, value, strlen(value));
 }
 
-bool redis_list::lset(const char* key, size_t idx,
-	const char* value, size_t len)
+bool redis_list::lset(const char* key, int idx, const char* value, size_t len)
 {
 	const char* argv[4];
 	size_t lens[4];
@@ -469,7 +461,7 @@ bool redis_list::brpoplpush(const char* src, const char* dst,
 	return conn_->get_string(buf) >= 0 ? true : false;
 }
 
-bool redis_list::lrange(const char* key, size_t start, size_t end,
+bool redis_list::lrange(const char* key, int start, int end,
 	std::vector<string>& result)
 {
 	const char* argv[4];
@@ -481,8 +473,8 @@ bool redis_list::lrange(const char* key, size_t start, size_t end,
 	lens[1] = strlen(key);
 
 	char start_s[LONG_LEN], end_s[LONG_LEN];
-	safe_snprintf(start_s, sizeof(start_s), "%lu", (unsigned long) start);
-	safe_snprintf(end_s, sizeof(end_s), "%lu", (unsigned long) end);
+	safe_snprintf(start_s, sizeof(start_s), "%d", start);
+	safe_snprintf(end_s, sizeof(end_s), "%d", end);
 
 	argv[2] = start_s;
 	lens[2] = strlen(start_s);
@@ -520,7 +512,7 @@ int redis_list::lrem(const char* key, int count, const char* value, size_t len)
 	return conn_->get_number();
 }
 
-bool redis_list::ltrim(const char* key, size_t start, size_t end)
+bool redis_list::ltrim(const char* key, int start, int end)
 {
 	const char* argv[4];
 	size_t lens[4];
@@ -531,8 +523,8 @@ bool redis_list::ltrim(const char* key, size_t start, size_t end)
 	lens[1] = strlen(key);
 
 	char start_s[LONG_LEN], end_s[LONG_LEN];
-	safe_snprintf(start_s, sizeof(start_s), "%lu", (unsigned long) start);
-	safe_snprintf(end_s, sizeof(end_s), "%lu", (unsigned long) end);
+	safe_snprintf(start_s, sizeof(start_s), "%d", start);
+	safe_snprintf(end_s, sizeof(end_s), "%d", end);
 
 	argv[2] = start_s;
 	lens[2] = strlen(start_s);
diff --git a/lib_acl_cpp/src/redis/redis_set.cpp b/lib_acl_cpp/src/redis/redis_set.cpp
index cd3bae49d..85efab4b4 100644
--- a/lib_acl_cpp/src/redis/redis_set.cpp
+++ b/lib_acl_cpp/src/redis/redis_set.cpp
@@ -351,29 +351,6 @@ int redis_set::srandmember(const char* key, size_t n, std::vector<string>& out)
 	return conn_->get_strings(out);
 }
 
-int redis_set::srem(const char* key, const char* member)
-{
-	return srem(key, member, strlen(member));
-}
-
-int redis_set::srem(const char* key, const char* member, size_t len)
-{
-	const char* argv[3];
-	size_t lens[3];
-
-	argv[0] = "SREM";
-	lens[0] = sizeof("SREM") - 1;
-
-	argv[1] = key;
-	lens[1] = strlen(key);
-
-	argv[2] = member;
-	lens[2] = len;
-
-	conn_->build_request(3, argv, lens);
-	return conn_->get_number();
-}
-
 int redis_set::srem(const char* key, const char* first_member, ...)
 {
 	std::vector<const char*> members;
diff --git a/lib_acl_cpp/src/redis/redis_string.cpp b/lib_acl_cpp/src/redis/redis_string.cpp
index e317fd965..da0c959cc 100644
--- a/lib_acl_cpp/src/redis/redis_string.cpp
+++ b/lib_acl_cpp/src/redis/redis_string.cpp
@@ -184,12 +184,12 @@ bool redis_string::getset(const char* key, size_t key_len,
 
 /////////////////////////////////////////////////////////////////////////////
 
-int redis_string::str_len(const char* key)
+int redis_string::get_strlen(const char* key)
 {
-	return str_len(key, strlen(key));
+	return get_strlen(key, strlen(key));
 }
 
-int redis_string::str_len(const char* key, size_t len)
+int redis_string::get_strlen(const char* key, size_t len)
 {
 	const char* argv[2];
 	size_t lens[2];
@@ -262,12 +262,13 @@ bool redis_string::getrange(const char* key, size_t key_len,
 
 /////////////////////////////////////////////////////////////////////////////
 
-bool redis_string::setbit(const char* key, unsigned offset, int bit)
+bool redis_string::setbit(const char* key, unsigned offset, bool bit)
 {
 	return setbit(key, strlen(key), offset, bit);
 }
 
-bool redis_string::setbit(const char* key, size_t len, unsigned offset, int bit)
+bool redis_string::setbit(const char* key, size_t len,
+	unsigned offset, bool bit)
 {
 	const char* argv[4];
 	size_t lens[4];
diff --git a/lib_acl_cpp/src/redis/redis_transaction.cpp b/lib_acl_cpp/src/redis/redis_transaction.cpp
index 3beb8267f..a303b948c 100644
--- a/lib_acl_cpp/src/redis/redis_transaction.cpp
+++ b/lib_acl_cpp/src/redis/redis_transaction.cpp
@@ -24,14 +24,19 @@ bool redis_transaction::watch(const std::vector<string>& keys)
 	return conn_->get_status();
 }
 
-bool redis_transaction::unwatch(const std::vector<string>& keys)
+bool redis_transaction::unwatch()
 {
-	conn_->build("UNWATCH", NULL, keys);
+	const char* argv[1];
+	size_t lens[1];
+
+	conn_->build_request(1, argv, lens);
 	return conn_->get_status();
 }
 
 bool redis_transaction::multi()
 {
+	cmds_.clear();
+
 	const char* argv[1];
 	size_t lens[1];