没有商业目的.纯粹交流经验.
Redis作者详谈2.4版本改进
本文内容来源于Redis作者 ，由NoSQLFan进行翻译。在文中他首先解释了由于Redis集群可能在较长一段时间内还处理开发阶段，为了避免稳定版本由于这一原因被无限延后，于是从2.2版本fork出了一个2.4分支，这一分支目前进行了一些新的优化改进及bug修复，如果没有严重bug将会在近几个星期内发布稳定版本。
随后作者列出了2.4版本中的一大堆优化改进及Bug修复，主要有下面一些：
对小数据量的sorted sets结构的内存使用做很大的优化RDB文件的持久化速度也将会大大提高对目前的一些写操作命令进行了改进，支持批量写入功能启用新的内存分配模式 jemalloc.通过对copy on write机制使用的优化，数据持久化保存的子进程的内存占用将大大减少INFO内容更加丰富新的OBJECT命令，提供对Redis存储value结构描述新的CLIENT命令，提供对Redis客户端连接的信息描述彻底将Slave对Master的连接改成非阻塞，之前connect(2)系统调用是会阻塞的Redis-benchmark、Redis-cli 都进行了几个方面的改进Make 改为彩色输出，更易读VM机制彻底废弃总的来说2.4版本会在各方面有性能上的提升Redis测试框架也有非常大的提升
后面又详细对其中的一些方面做了深入讲解
1. 对Sorted Sets的内存优化
实际上在2.2版本中，Redis就对小数据量Value的情况做了性能优化，主要优化方式是将小数据量的Value值不再按具体的数据结构存储，而是存在一块二进制的整块数据。而这一改进一直没能应用于Sorted Sets数据结构上来，而在2.4版本中，作者终于想到合适的办法把Sorted Sets在小数据量下也进行了此种优化。
2. RDB文件持久化提速
这块很大程度上依赖于上面第1点，由于小量数据被存为一个大的二进制数据块，所以在持久化的时候，就不需要再遍历数据了，只需要一个key进行一次持久化写入。
3. 提供批量写入功能
下面是所有提供批量写入功能的命令
SADD set val1 val2 val3 … — 返回添加的元素个数HDEL hash field2 field3 field3 … — 返回删除的元素个数SREM set val1 val2 val3 … – 返回删除的元素个数ZREM zset val1 val2 val3 … – 返回删除的元素个数ZADD zset score1 val1 score2 val2 … – 返回添加的元素个数LPUSH/RLPUSH list val1 val2 val3 … – 返回操作后的LIST的长度
提供批量命令的效果是显而易见的，网络往返的时间被大大节约了，在最理想的网络情况下，作者的测试结果是一次性写入200w个元素，仅仅花费了1.28秒，每秒超过100w元素的写入！
为何不为所有写入命令都加上批量功能呢？作者解释说，由于很多命令在返回值上需要携带信息，如果改成批量的，无法批量返回信息内容。不过相信上面的改进已经可以让很多应用场景得到大大改进了。
4. 改用jemalloc的内存分配模式
Redis长期以来的思想就是尽量不产生外部依赖，比如网络事件库没有用传统的libevent库，而是自己单独抽离出几个文件组成的更简单且性能更高的网络事件启动库，这一库目前在很多开源项目中也被采用。而此次引入jemalloc实在是由于作者认为Linux下的glibc的内存分配器实在是太烂了，无法有效地防止碎片的产生。
虽然jemalloc是外部引入，你也不需要在安装Redis时先安装一堆东西，因为它已经包含在Redis源码里了，你还是像往常一样直接Make编译即可，还是那么方便贴心。
5. 减少 copy-on-write 使用
Redis的RDB文件持久化和AOF日志写入，都是通过调用fork()方法产生子进程来做的。由于主进程还是继续处理请求，当有数据写操作导致数据内容发生变化时，原来的内存段会被复制一份，这就是我们熟知的copy-on-write机制。而采用这一机制的问题就是，在最坏的情况下，进行一次RDB文件写入，可能导致使用内存加倍。所以在2.4版本中，作者对这一机制的使用进行了优化，大大减少了对copy-on-write的使用。
作者还坦言，自己在2.2版本中在这方面的一些修改是有问题的，这导致了2.2版本中的许多Bug。
6. INFO输出内容增强
2.4版本的INFO内容会有较大改变，其中比较重要的有下面两个
used_memory_peak:
used_memory_peak_human:177.08M
你的实际物理内存使用（RSS）和内存碎片情况通常都与最高峰内存使用相关，而这参数就是用来描述这些情况。一个是以byte为单位（），一个是自动智能单位（177.08M）。
7. 测试框架的优化和提速
这一点在NoSQLFan之前的文章《》中有比较详细的描述。有兴趣的朋友可以查看之前的文章。
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！一、单线程模型
　　Redis客户端对服务端的每次调用都经历了发送命令，执行命令，返回结果三个过程。其中执行命令阶段，由于Redis是单线程来处理命令的，所有每一条到达服务端的每一条到达服务端的命令都不会立刻执行，所有的命令都会进入一个队列中，然后逐个执行。并且多个客户端发送的命令的执行顺序是不确定的。但是可以确定的是不会有两条命令被同时执行，不会产生并发问题，这就是Redis的单线程基本模型。
二、单线程模型每秒万级别处理能力的原因
　　（1）纯内存访问。数据存放在内存中，内存的响应时间大约是100纳秒，这是Redis每秒万亿级别访问的重要基础。
　　（2）非阻塞I/O，Redis采用epoll做为I/O多路复用技术的实现，再加上Redis自身的事件处理模型将epoll中的连接，读写，关闭都转换为了时间，不在I/O上浪费过多的时间。
　　（3）单线程避免了线程切换和竞态产生的消耗。
　　（4）Redis采用单线程模型，每条命令执行如果占用大量时间，会造成其他线程阻塞，对于Redis这种高性能服务是致命的，所以Redis是面向高速执行的数据库。
三、Redis工作方式分析
　　Redis作为一个高性能的key-value数据库具有以下特征：&
　　多样的数据模型&
　　持久化&
　　主从同步 &
& & &Redis支持丰富的数据类型，最为常用的数据类型主要由五种：String、Hash、List、Set和Sorted&Set。Redis通常将数据存储于内存中，或被配置为使用虚拟内存。Redis有一个很重要的特点就是它可以实现持久化数
据，通过两种方式可以实现数据持久化：使用RDB快照的方式，将内存中的数据不断写入磁盘；或使用类似MySQL的AOF日志方式，记录每次更新的日志。前者性能较高，但是可能会引起一定程度的数据丢失；后者相反。 Redis支持将数据同步到多台从数据库上，这种特性对提高读取性能非常有益（Redis虽然读取写入的速度都特别快，但是也会产生读压力特别大的情况。为了分担读压力，Redis支持主从复制，Redis的主从结构可以采用一主多从或者级联结构）。
阅读(...) 评论()1.&& 命令帮助
通过Redis-cli中的help进行查看：
127.0.0.1:6379&help BLPOP
& BLPOP key [key ...] timeout
& summary: Remove and get the first element ina list, or block until one is available
& since: 2.0.0
& group: list
127.0.0.1:6379&help BRPOP
& BRPOP key [key ...] timeout
& summary: Remove and get the last element in alist, or block until one is available
& since: 2.0.0
& group: list
通过列表详细描述：
BLPOP key [key ...] timeout
LPOP 命令的阻塞版本；命令会以从左到右的顺序，访问给定的各个列表，并弹出首个非空列表最左端的项； 如果所有给定列表都为空，那么客户端将被阻塞，直到等待超时，或者有可弹出的项出现为 止；
设置 timeout参数为0表示永远阻塞。
O(N)，N 为输入列表的数量。
BRPOP key [key ...] timeout
RPOP命令的阻塞版本： 命令会以从左到右的顺序，访问给定的各个列表，并弹出首个非空列表最右端的项； 如果所有给定列表都为空，那么客户端将被阻塞，直到等待超时，或者有可弹出的项出现为 止；
设置 timeout参数为0表示永远阻塞。
O(N)，N 为输入列表的数量。
2. BLPOP/BRPOP实战
访问四个空的列表，并且设置阻塞时间为60秒
127.0.0.1:6379&BLPOP list1list2 list3 list4 60
通过返回的结果，nil表示等待超时，没有弹出数据，同时60.02s表示客户端被阻塞的时长。
下面我们设置list1列表的值为"Spark" "Hadoop" "Hive"，然后再进行如下操作：
127.0.0.1:6379&RPUSH list1& "Spark" "hadoop""hive"
(integer) 3
127.0.0.1:6379&LRANGE list1 0 -1
2)"Hadoop"
127.0.0.1:6379&BLPOP list1 list2 list3 list4 60
1)"list1" #执行弹出操作的列表
2)"Spark" #被弹出的项
我们发现list1不为空，于是执行弹出命令(#后面为注释)。
我们也可以先执行阻塞操作，然后在等待过程设置列表的值，如下：
终端A: 执行如下命令，阻塞中
127.0.0.1:6379&BLPOP list2 list3 list4 60
终端B: 设置list2值
127.0.0.1:6379&RPUSH list2 "Scala" "Sqoop"
(integer) 2
同时我们查看终端A时会发现，已经弹出结果了
127.0.0.1:6379&BLPOP list2 list3 list4 60
1)"list2" #执行弹出操作的列表
2)"scala" #被弹出的项
(6.28s)&&& #客户端被阻塞的时长
3. 下面介绍几种情形：
3.1 非阻塞
当发现给定的列表中至少一个非空列表时，BLPOP和BRPOP就会立即从那个列表里面弹出元素，
在这种情况下，BLPOP就像一个接受多参数的LPOP命令，而BRPOP就像一个接受多参数的RPOP命令。
3.2 阻塞并超时
如果所有给定的列表都是空的，那么BLPOP/BRPOP将被被阻塞。
如果在阻塞的过程中，给定的列表一直没有新项被推入，那么当设定的超时时间到达之后，
命令将向被阻塞的客户端返回nil。
3.3 阻塞并弹出情况
如果在客户端A被阻塞的过程中，有另一个客户端B给造成客户端A被阻塞的列表推入了新项，那么
服务器会将这个新项返回给客户端A。
4. BLPOP/BRPOP的先到先服务原则
如果有多个客户端同时因为某个列表而被阻塞，那么当有新值被推入到这个列表时，服务器就会按照先到先服务原则，优先向最早被阻塞的客户端返回新值。
阅读(...) 评论()Redis数据类型之LIST类型
list类型-特点
list 是一个链表结构，主要功能是 push、pop、获取一个范围的所有值等等，操作中 key理解为链表的名字。
Redis 的 list类型其实就是一个每个子元素都是 string 类型的双向链表。链表的最大长度是(2的 32 次方)。我们可以通过 push,pop 操作从链表的头部或者尾部添加删除元素。这使得 list既可以用作栈，也可以用作队列。
有意思的是 list 的 pop 操作还有阻塞版本的，当我们[lr]pop 一个 list 对象时，如果 list 是空，或者不存在，会立即返回 nil。但是阻塞版本的 b[lr]pop 可以则可以阻塞，当然可以加超时时间，超时后也会返回 nil。为什么要阻塞版本的 pop 呢，主要是为了避免轮询。举个简单的例子如果我们用 list 来实现一个工作队列。 执行任务的 thread 可以调用阻塞版本的 pop 去获取任务这样就可以避免轮询去检查是否有任务存在。当任务来时候工作线程可以立即返回，也可以避免轮询带来的延迟。
list类型-应用场景
Redis list应用场景非常多，也是Redis最重要的数据结构之一，比如微博的关注列表，粉丝列表等都可以用Redis的list结构来实现；博客实现中，可为每篇日志设置一个list，在该list中推入进博客评论；也可以使用Redis list实现消息队列。
list中的数据逻辑上存在顺序关系（数组的下表），适合存储带有顺序特性（空间、时间属性）的数据。比如，记录用户在网站上浏览商品id，这种带时间属性的数据可以用来分析用户的购物行为。
list作为queue，一端加入数据，另一端读取数据，最典型的就是生产者/消费者模型，比如：商品秒杀，从已经初始化队列中pop出数据，直到队列为空。
list作为stack，只操作list的一端，数据先进后出。
list常见命令
LPUSH key value [value &]
将一个或多个值 value 插入到列表 key 的表头如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头：比如说，对空列表 mylist执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPUSH mylist a 、LPUSH mylist b 和 LPUSH mylist c 三个命令。
如果 key 不存在，一个空列表会被创建并执行LPUSH 操作。
当 key 存在但不是列表类型时，返回一个错误。
时间复杂度： O(1)
返回值： 执行LPUSH 命令后，列表的长度。
127.0.0.1:6379[15]& LPUSH languages python
(integer) 1
127.0.0.1:6379[15]& LPUSH languages python
(integer) 2
127.0.0.1:6379[15]& LRANGE languages 0 -1
1) &python&
2) &python&
127.0.0.1:6379[15]& LPUSH mylist a b c
(integer) 3
127.0.0.1:6379[15]& LRANGE mylist 0 -1
LPUSHX key value
将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。
和LPUSH 命令相反，当 key 不存在时，LPUSHX 命令什么也不做。
时间复杂度： O(1)
返回值： LPUSHX 命令执行之后，表的长度。
127.0.0.1:6379[15]& LLEN greet
(integer) 0
127.0.0.1:6379[15]& LPUSHX greet &hello&
(integer) 0
127.0.0.1:6379[15]& LPUSH greet &hello&
(integer) 1
127.0.0.1:6379[15]& LPUSHX greet &good morning&
(integer) 2
127.0.0.1:6379[15]& LRANGE greet 0 -1
1) &good morning&
2) &hello&
RPUSH key value [value &]
将一个或多个值 value 插入到列表 key 的表尾 (最右边)。
如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、RPUSH mylist b 、RPUSH mylist c 。
如果 key 不存在，一个空列表会被创建并执行RPUSH 操作。
当 key 存在但不是列表类型时，返回一个错误。
时间复杂度： O(1)
返回值： 执行RPUSH 操作后，表的长度。
127.0.0.1:6379[15]& RPUSH languages c
(integer) 1
127.0.0.1:6379[15]& RPUSH languages c
(integer) 2
127.0.0.1:6379[15]& LRANGE languages 0 -1
127.0.0.1:6379[15]& RPUSH mylist a b c
(integer) 3
127.0.0.1:6379[15]& LRANGE mylist 0 -1
RPUSHX key value
将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。
和RPUSH 命令相反，当 key 不存在时，RPUSHX 命令什么也不做。
时间复杂度： O(1)
返回值： RPUSHX 命令执行之后，表的长度。
127.0.0.1:6379[15]& LLEN greet
(integer) 0
127.0.0.1:6379[15]& LPUSHX greet &hello&
(integer) 0
127.0.0.1:6379[15]& LPUSH greet &hello&
(integer) 1
127.0.0.1:6379[15]& LPUSHX greet &good morning&
(integer) 2
127.0.0.1:6379[15]& LRANGE greet 0 -1
1) &good morning&
2) &hello&
移除并返回列表 key 的头元素。
时间复杂度： O(1)
　　列表的头元素。
　　当 key 不存在时，返回 nil 。
127.0.0.1:6379[15]& LLEN course
(integer) 0
127.0.0.1:6379[15]& RPUSH course algorithm001
(integer) 1
127.0.0.1:6379[15]& RPUSH course c++101
(integer) 2
127.0.0.1:6379[15]& LPOP course
&algorithm001&
移除并返回列表 key 的尾元素。
时间复杂度： O(1)
　　列表的尾元素。
　　当 key 不存在时，返回 nil 。
127.0.0.1:6379[15]& RPUSH mylist &one&
(integer) 1
127.0.0.1:6379[15]& RPUSH mylist &two&
(integer) 2
127.0.0.1:6379[15]& RPUSH mylist &three&
(integer) 3
127.0.0.1:6379[15]& RPOP mylist
127.0.0.1:6379[15]& LRANGE mylist 0 -1
BLPOP key [key &] timeout
BLPOP 是列表的阻塞式 (blocking) 弹出原语。
它是LPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。非阻塞行为当BLPOP 被调用时，如果给定 key 内至少有一个非空列表，那么弹出遇到的第一个非空列表的头元素，并和被弹出元素所属的列表的名字一起，组成结果返回给调用者。
当存在多个给定 key 时，BLPOP 按给定 key 参数排列的先后顺序，依次检查各个列表。
假设现在有 job 、command 和 request 三个列表，其中 job 不存在，command 和 request 都持有非空列表。考虑以下命令：
BLPOP job command request 0
BLPOP 保证返回的元素来自 command，因为它是按& 查找 job -& 查找 command -& 查找 request &这样的顺序，第一个找到的非空列表。
127.0.0.1:6379[15]& DEL job command request
(integer) 0
127.0.0.1:6379[15]& LPUSH command &update system...&
(integer) 1
127.0.0.1:6379[15]& LPUSH request &visit page&
(integer) 1
127.0.0.1:6379[15]& BLPOP job command request 0
1) &command&
2) &update system...&
BRPOP key [key &] timeout
BRPOP 是列表的阻塞式 (blocking) 弹出原语。
它是RPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被BRPOP 命令阻塞，直 到等待超时或发现可弹出元素为止。
当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。
关于阻塞操作的更多信息，请查看BLPOP 命令，BRPOP 除了弹出元素的位置和BLPOP 不同之外，其他表现一致。
时间复杂度： O(1)
　　假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。
　　反之，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。
127.0.0.1:6379[15]& LLEN course
(integer) 0
127.0.0.1:6379[15]& RPUSH course algorithm001
(integer) 1
127.0.0.1:6379[15]& RPUSH course c++101
(integer) 2
127.0.0.1:6379[15]& BRPOP course 30
1) &course&
2) &c++101&
LINSERT key BEFORE|AFTER pivot value
将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。
当 pivot 不存在于列表 key 时，不执行任何操作。
当 key 不存在时，key 被视为空列表，不执行任何操作。
如果 key 不是列表类型，返回一个错误。
时间复杂度: O(N)，N 为寻找 pivot 过程中经过的元素数量。
　　如果命令执行成功，返回插入操作完成之后，列表的长度。
　　如果没有找到 pivot ，返回 -1 。
　　如果 key 不存在或为空列表，返回 0 。
127.0.0.1:6379[15]& RPUSH mylist &Hello&
(integer) 1
127.0.0.1:6379[15]& RPUSH mylist &World&
(integer) 2
127.0.0.1:6379[15]& LINSERT mylist BEFORE &World& &There&
(integer) 3
127.0.0.1:6379[15]& LRANGE mylist 0 -1
1) &Hello&
2) &There&
3) &World&
127.0.0.1:6379[15]& LINSERT mylist BEFORE &go& &let's&
(integer) -1
127.0.0.1:6379[15]& EXISTS fake_list
(integer) 0
127.0.0.1:6379[15]& LINSERT fake_list BEFORE &nono& &gogogog&
(integer) 0
LRANGE key start stop
返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
下标 (index) 参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素，-2 表示列表的倒数第二个元素，以此类推。
注意 LRANGE 命令和语言区间函数的区别假如你有一个包含一百个元素的列表，对该列表执行 LRANGE list 0 10 ，结果是一个包含 11 个元素的列表，这表明 stop下标也在LRANGE命令的取值范围之内 (闭区间)，这和某些语言的区间函数可能不一致，比如 Ruby 的 Range.new 、Array#slice 和
的 range() 函数。
超出范围的下标值不会引起错误。
如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 ) 还要大，那么LRANGE 返回一个空列表。
如果 stop 下标比 end 下标还要大，Redis 将 stop 的值设置为 end 。
时间复杂度: O(S+N)，S 为偏移量 start ，N 为指定区间内元素的数量。
返回值: 一个列表，包含指定区间内的元素。
127.0.0.1:6379[15]&
RPUSH fp-language lisp
(integer) 1
127.0.0.1:6379[15]&
LRANGE fp-language 0 0
127.0.0.1:6379[15]&
RPUSH fp-language scheme
(integer) 2
127.0.0.1:6379[15]&
LRANGE fp-language 0 1
2) &scheme&
LREM key count value
根据参数 count 的值，移除列表中与参数 value 相等的元素。
count 的值可以是以下几种：
　　count & 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
　　count & 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
　　count = 0 : 移除表中所有与 value 相等的值。
时间复杂度： O(N)，N 为列表的长度。
　　被移除元素的数量。
　　因为不存在的 key 被视作空表 (empty list)，所以当 key 不存在时，LREM 命令总是返回 0 。
127.0.0.1:6379[15]& LPUSH greet &morning&
(integer) 1
127.0.0.1:6379[15]& LPUSH greet &hello&
(integer) 2
127.0.0.1:6379[15]& LPUSH greet &morning&
(integer) 3
127.0.0.1:6379[15]& LPUSH greet &hello&
(integer) 4
127.0.0.1:6379[15]& LPUSH greet &morning&
(integer) 5
127.0.0.1:6379[15]& LRANGE greet 0 4
1) &morning&
2) &hello&
3) &morning&
4) &hello&
5) &morning&
127.0.0.1:6379[15]& LREM greet 2 morning
(integer) 2
127.0.0.1:6379[15]& LLEN greet
(integer) 3
127.0.0.1:6379[15]& LRANGE greet 0 2
1) &hello&
2) &hello&
3) &morning&
127.0.0.1:6379[15]& LREM greet -1 morning
(integer) 1
127.0.0.1:6379[15]& LLEN greet
(integer) 2
127.0.0.1:6379[15]& LRANGE greet 0 1
1) &hello&
2) &hello&
127.0.0.1:6379[15]& LREM greet 0 hello
(integer) 2
127.0.0.1:6379[15]& LLEN greet
(integer) 0
LTRIM key start stop
对一个列表进行修剪 (trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。
下标 (index) 参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素，-2 表示列表的倒数第二个元素，以此类推。当 key 不是列表类型时，返回一个错误。
LTRIM 命令通常和LPUSH 命令或RPUSH 命令配合使用，举个例子：
LPUSH log newest_log
LTRIM log 0 99
这个例子模拟了一个日志程序，每次将最新日志 newest_log 放到 log 列表中，并且只保留最新的 100 项。注意当这样使用 LTRIM 命令时，时间复杂度是 O(1)，因为平均情况下，每次只有一个元素被移除。
注意 LTRIM 命令和编程语言区间函数的区别
假如你有一个包含一百个元素的列表 list ，对该列表执行 LTRIM list 0 10 ，结果是一个包含 11 个元素的列表，这表明 stop 下标也在LTRIM 命令的取值范围之内 (闭区间)，这和某些语言的区间函数可能不一致，比如 Ruby 的 Range.new 、Array#slice 和 Python 的 range() 函数。
超出范围的下标值不会引起错误。
如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 ) 还要大，或者 start & stop ，LTRIM 返回一个空列表 (因为LTRIM 已经将整个列表清空)。
如果 stop 下标比 end 下标还要大，Redis 将 stop 的值设置为 end 。
时间复杂度: O(N)，N 为被移除的元素的数量。
返回值:命令执行成功时，返回 ok 。
# 情况 1： 常见情况， start 和 stop 都在列表的索引范围之内
127.0.0.1:6379[15]& LPUSH alpha h e l l o
(integer) 5
127.0.0.1:6379[15]& LRANGE alpha 0 -1
127.0.0.1:6379[15]&
LTRIM alpha 1 -1
127.0.0.1:6379[15]& LRANGE alpha 0 -1
# o被删除了
# 情况 2： stop 比列表的最大下标还要大
127.0.0.1:6379[15]&
LTRIM alpha 1 10086
127.0.0.1:6379[15]&
LRANGE alpha 0 -1 # 只有索引 0 上的元素 &l& 被删除了，其他元素还在
127.0.0.1:6379[15]& LTRIM alpha
# 情况 4： start 和 stop 都比列表的最大下标要大，并且 start & stop
127.0.0.1:6379[15]& LRANGE alpha 0 -1
(empty list or set)
127.0.0.1:6379[15]& RPUSH new-alpha &h& &e& &l& &l& &o&
(integer) 5
127.0.0.1:6379[15]& LRANGE new-alpha 0 -1
127.0.0.1:6379[15]& LTRIM new-alpha 86
127.0.0.1:6379[15]& LRANGE new-alpha 0 -1
(empty list or set)
LSET key index value
将列表 key 下标为 index 的元素的值设置为 value 。
当 index 参数超出范围，或对一个空列表 ( key 不存在) 进行LSET 时，返回一个错误。
时间复杂度：
　　对头元素或尾元素进行LSET 操作，复杂度为 O(1)。
　　其他情况下，为 O(N)，N 为列表的长度。
返回值： 操作成功返回 ok ，否则返回错误信息。
127.0.0.1:6379[15]& EXISTS list
(integer) 0
127.0.0.1:6379[15]& LSET list 0 item
(error) ERR no such key
127.0.0.1:6379[15]& LPUSH job &cook food&
(integer) 1
127.0.0.1:6379[15]& LRANGE job 0 0
1) &cook food&
127.0.0.1:6379[15]& LSET job 0 &play game&
127.0.0.1:6379[15]& LRANGE job 0 0
1) &play game&
127.0.0.1:6379[15]& LPUSH list a
(integer) 1
127.0.0.1:6379[15]& llen list
(integer) 1
127.0.0.1:6379[15]& LSET list 3 b
(error) ERR index out of range
LINDEX key index
返回列表 key 中，下标为 index 的元素。
下标 (index) 参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素，-2 表示列表的倒数第二个元素，以此类推。如果 key 不是列表类型，返回一个错误。
时间复杂度：
　　O(N)，N 为到达下标 index 过程中经过的元素数量。
　　因此，对列表的头元素和尾元素执行LINDEX 命令，复杂度为 O(1)。
　　列表中下标为 index 的元素。
　　如果 index 参数的值不在列表的区间范围内 (out of range)，返回 nil 。
127.0.0.1:6379[15]&
LPUSH mylist &World&
(integer) 1
127.0.0.1:6379[15]& LPUSH mylist &Hello&
(integer) 2
127.0.0.1:6379[15]&
LINDEX mylist 0
127.0.0.1:6379[15]&
LINDEX mylist -1
127.0.0.1:6379[15]&
LINDEX mylist 3
返回列表 key 的长度。
如果 key 不存在，则 key 被解释为一个空列表，返回 0 .
如果 key 不是列表类型，返回一个错误。
时间复杂度： O(1)
返回值： 列表 key 的长度。
127.0.0.1:6379[15]& LLEN job
(integer) 0
127.0.0.1:6379[15]& LPUSH job &cook food&
(integer) 1
127.0.0.1:6379[15]& LPUSH job &have lunch&
(integer) 2
127.0.0.1:6379[15]& LLEN job
(integer) 2
RPOPLPUSH source destination
命令RPOPLPUSH 在一个原子时间内，执行以下两个动作：
　　将列表 source 中的最后一个元素 (尾元素) 弹出，并返回给客户端。
　　将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。
举个例子，你有两个列表 source 和 destination ，source 列表有元素 a, b, c ，destination 列表有元素 x, y, z ，执行 RPOPLPUSH source destination 之后，source 列表包含元素 a, b ，destination 列表包含元素 c, x, y, z ，并且元素 c 会被返回给客户端。
如果 source 不存在，值 nil 被返回，并且不执行其他动作。
如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转 (rotation) 操作。
时间复杂度： O(1)
返回值： 被弹出的元素。
127.0.0.1:6379[15]& LPUSH alpha d c b a
(integer) 4
127.0.0.1:6379[15]& LRANGE alpha 0 -1
127.0.0.1:6379[15]& RPOPLPUSH alpha reciver
127.0.0.1:6379[15]& LRANGE alpha 0 -1
127.0.0.1:6379[15]& LRANGE reciver 0 -1
127.0.0.1:6379[15]& RPOPLPUSH alpha reciver
127.0.0.1:6379[15]& LRANGE alpha 0 -1
127.0.0.1:6379[15]& LRANGE reciver 0 -1
source 和 destination 相同
127.0.0.1:6379[15]& RPUSH number 1 2 3 4
(integer) 4
127.0.0.1:6379[15]& LRANGE number 0 -1
127.0.0.1:6379[15]& RPOPLPUSH number number
127.0.0.1:6379[15]& LRANGE number 0 -1
127.0.0.1:6379[15]& RPOPLPUSH number number
127.0.0.1:6379[15]& LRANGE number 0 -1
BRPOPLPUSH
BRPOPLPUSH source destination timeout
BRPOPLPUSH 是RPOPLPUSH 的阻塞版本，当给定列表 source 不为空时，BRPOPLPUSH 的表现和RPOPLPUSH 一样。
当列表 source 为空时，BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行LPUSH 或RPUSH 命令为止。
超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。
时间复杂度： O(1)
　　假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。
　　反之，返回一个含有两个元素的列表，第一个元素是被弹出元素的值，第二个元素是等待时长。
127.0.0.1:6379[15]& BRPOPLPUSH msg reciver 500
127.0.0.1:6379[15]& LLEN reciver
(integer) 1
127.0.0.1:6379[15]& LRANGE reciver 0 0
1) &hello&
127.0.0.1:6379[15]& BRPOPLPUSH msg reciver 1}