概述

链表结构是 Redis 中一个常用的结构，它可以存储多个字符串

它是有序的

能够存储2的32次方减一个节点（超过 40 亿个节点）

Redis 链表是双向的，因此即可以从左到右，也可以从右到左遍历它存储的节点

链表结构查找性能不佳，但插入和删除速度很快

由于是双向链表，所以只能够从左到右，或者从右到左地访问和操作链表里面的数据节点。但是使用链表结构就意味着读性能的丧失，所以要在大量数据中找到一个节点的操作性能是不佳的，因为链表只能从一个方向中去遍历所要节点，比如从查找节点 10000 开始查询，它需要按照节点1 、节点 2、节点 3……直至节点 10000，这样的顺序查找，然后把一个个节点和你给出的值比对，才能确定节点所在。如果这个链表很大，如有上百万个节点，可能需要遍历几十万次才能找到所需要的节点，显然查找性能是不佳的。

链表结构的优势在于插入和删除的便利，因为链表的数据节点是分配在不同的内存区域的，并不连续，只是根据上一个节点保存下一个节点的顺序来索引而己，无需移动元素。

因为是双向链表结构，所以 Redis 链表命令分为左操作和右操作两种命令，左操作就意味着是从左到右，右操作就意味着是从右到左。

Redis 关于链表的命令

官网： https://redis.io/commands#list

对于很多个节点同时操作的，需要考虑其花费的时间，链表数据结构对于查找而言并不适合于大数据。我们需要考虑插入和删除内容的大小，因为这将是十分消耗性能的命令，会导致 Redis 服务器的卡顿。对于不允许卡顿的一些服务器，可以进行分批次操作，以避免出现卡顿。

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> LPUSH list node3 node2 node1
(integer) 3
127.0.0.1:6379> RPUSH list node4
(integer) 4
127.0.0.1:6379> LINDEX list 0
"node1"
127.0.0.1:6379> LLEN list
(integer) 4
127.0.0.1:6379> LPOP list
"node1"
127.0.0.1:6379> RPOP list
"node4"
127.0.0.1:6379> LINSERT list before node2 before_node
(integer) 3
127.0.0.1:6379> LINSERT list after node2 after_node
(integer) 4
127.0.0.1:6379> LPUSHX list head
(integer) 5
127.0.0.1:6379> RPUSHX list end
(integer) 6
127.0.0.1:6379> LRANGE list 0 10
1) "head"
2) "before_node"
3) "node2"
4) "after_node"
5) "node3"
6) "end"
127.0.0.1:6379> LPUSH list node node node 
(integer) 9
127.0.0.1:6379> LREM list 3 node 
(integer) 3
127.0.0.1:6379> LSET list 0 new_head_value
OK
127.0.0.1:6379> LRANGE list 0 10
1) "new_head_value"
2) "before_node"
3) "node2"
4) "after_node"
5) "node3"
6) "end"
127.0.0.1:6379> LTRIM list 0 2 
OK
127.0.0.1:6379> LRANGE list 0 10
1) "new_head_value"
2) "before_node"
3) "node2"
127.0.0.1:6379>

使用 Spring 操作 Redis 链表命令

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:p="http://www.springframework.org/schema/p"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:redis/redis.properties" />
    <!--2,注意新版本2.3以后，JedisPoolConfig的property name，不是maxActive而是maxTotal，而且没有maxWait属性，建议看一下Jedis源码或百度。 -->
    <!-- redis连接池配置 -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!--最大空闲数 -->
        <property name="maxIdle" value="${redis.maxIdle}" />
        <!--连接池的最大数据库连接数 -->
        <property name="maxTotal" value="${redis.maxTotal}" />
        <!--最大建立连接等待时间 -->
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
        <!--逐出连接的最小空闲时间 默认1800000毫秒(30分钟) -->
        <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />
        <!--每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3 -->
        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />
        <!--逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1 -->
        <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />
      <property name="testOnBorrow" value="true"></property>
    <property name="testOnReturn" value="true"></property>
    <property name="testWhileIdle" value="true"></property>
    </bean>
  <!--redis连接工厂 -->
    <bean id="jedisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
        destroy-method="destroy">
        <property name="poolConfig" ref="jedisPoolConfig"></property>
        <!--IP地址 -->
        <property name="hostName" value="${redis.host.ip}"></property>
        <!--端口号 -->
        <property name="port" value="${redis.port}"></property>
        <!--如果Redis设置有密码 -->
        <property name="password" value="${redis.password}" /> 
        <!--客户端超时时间单位是毫秒 -->
        <property name="timeout" value="${redis.timeout}"></property>
        <property name="usePool" value="true" />
        <!--<property name="database" value="0" /> -->
    </bean>
  <!-- 键值序列化器设置为String 类型 -->
  <bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
  <!-- redis template definition -->
  <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
    p:connection-factory-ref="jedisConnectionFactory"
    p:keySerializer-ref="stringRedisSerializer"
    p:defaultSerializer-ref="stringRedisSerializer"
    p:valueSerializer-ref="stringRedisSerializer">
  </bean>
</beans>

package com.artisan.redis.baseStructure.list;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.connection.RedisListCommands;
import org.springframework.data.redis.core.RedisTemplate;
public class SpringRedisListDemo {
  private static String key = "list";
  public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:spring/spring-redis-list.xml");
    RedisTemplate redisTemplate = (RedisTemplate) ctx.getBean("redisTemplate");
    // 不管存不存在，先根据key清理掉链表，方便测试
    Boolean flag  = redisTemplate.delete(key);
    System.out.println((flag = true) ? "删除list成功" : "删除list失败");
    // 127.0.0.1:6379> LPUSH list node3 node2 node1
    // (integer) 3
    // 把 node3 插入链表 list
    System.out.println(redisTemplate.opsForList().leftPush(key, "node3"));
    // 相当于 lpush 把多个价值从左插入链表
    List<String> nodeList = new ArrayList<String>();
    for (int i = 2; i >= 1; i--) {
      nodeList.add("node" + i);
    }
    System.out.println(redisTemplate.opsForList().leftPushAll(key, nodeList));
    // 127.0.0.1:6379> RPUSH list node4
    // (integer) 4
    // 从右边插入一个节点
    System.out.println(redisTemplate.opsForList().rightPush(key, "node4"));
    // 127.0.0.1:6379> LINDEX list 0
    // "node1"
    // 获取下标为 0 的节点
    String node = (String) redisTemplate.opsForList().index(key, 0);
    System.out.println("第一个节点:" + node);
    // 127.0.0.1:6379> LLEN list
    // (integer) 4
    // 获取链表长度
    System.out.println(key + "中的总数为：" + redisTemplate.opsForList().size(key));
    // 127.0.0.1:6379> LPOP list
    // "node1"
    // 从左边弹出 一个节点
    String leftPopNode = (String) redisTemplate.opsForList().leftPop(key);
    System.out.println("leftPopNode:" + leftPopNode);
    // 127.0.0.1:6379> RPOP list
    // "node4"
    // 从右边弹出 一个节点
    String rightPopNode = (String) redisTemplate.opsForList().rightPop(key);
    System.out.println("rightPopNode:" + rightPopNode);
    // 注意，需要使用更为底层的命令才能操作 linsert 命令
    // 127.0.0.1:6379> LINSERT list before node2 before_node
    // (integer) 3
    // 使用 linsert 命令在node2 前插入一个节点
    try {
      Long long1 = redisTemplate.getConnectionFactory().getConnection()
          .lInsert(key.getBytes("utf-8"), RedisListCommands.Position.BEFORE, "node2".getBytes("utf-8"), "before_node".getBytes("utf-8"));
      System.out.println(long1);
    } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
    }
    // 127.0.0.1:6379> LINSERT list after node2 after_node
    // (integer) 4
    // 使用 linsert 命令在 node2 后插入一个节点
    try {
      Long long2 = redisTemplate.getConnectionFactory().getConnection()
          .lInsert(key.getBytes("utf-8"), RedisListCommands.Position.AFTER, "node2".getBytes("utf-8"), "after_node".getBytes("utf-8"));
      System.out.println(long2);
    } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
    }
    // 127.0.0.1:6379> LPUSHX list head
    // (integer) 5
    // 判断 list 是否存在，如果存在则从左边插入 head 节点
    System.out.println(redisTemplate.opsForList().leftPushIfPresent(key, "head"));
    // 127.0.0.1:6379> RPUSHX list end
    // (integer) 6
    // 判断 list 是否存在，如果存在则从右边插入 end 节点
    System.out.println(redisTemplate.opsForList().rightPushIfPresent(key, "end"));
    // 127.0.0.1:6379> LRANGE list 0 10
    // 1) "head"
    // 2) "before_node"
    // 3) "node2"
    // 4) "after_node"
    // 5) "node3"
    // 6) "end"
    List<String> list = redisTemplate.opsForList().range(key, 0, 10);
    for (String string : list) {
      System.out.println("节点：" + string);
    }
    // 127.0.0.1:6379> LPUSH list node node node
    // (integer) 9
    // 在链表左边插入三个值为 node 的节点
    nodeList.clear();
    for (int i = 0; i < 3; i++) {
      nodeList.add("node");
    }
    System.out.println(redisTemplate.opsForList().leftPushAll(key, nodeList));
    // 127.0.0.1:6379> LREM list 3 node
    // (integer) 3
    // 从左到右删除至多三个 node 节点
    System.out.println(redisTemplate.opsForList().remove(key, 3, "node"));
    // 127.0.0.1:6379> LSET list 0 new_head_value
    // OK
    // 给链表下标为 0 的节点设置新值
    redisTemplate.opsForList().set(key, 0, "new_head_value");
    // 127.0.0.1:6379> LRANGE list 0 10
    // 1) "new_head_value"
    // 2) "before_node"
    // 3) "node2"
    // 4) "after_node"
    // 5) "node3"
    // 6) "end"
    list = redisTemplate.opsForList().range(key, 0, 10);
    for (String string : list) {
      System.out.println("节点：" + string);
    }
    // 127.0.0.1:6379> LTRIM list 0 2
    // OK
    redisTemplate.opsForList().trim(key, 0, 2);
    System.out.println("---------------------");
    // 127.0.0.1:6379> LRANGE list 0 10
    // 1) "new_head_value"
    // 2) "before_node"
    // 3) "node2"
    list = redisTemplate.opsForList().range(key, 0, 10);
    for (String string : list) {
      System.out.println("节点：" + string);
    }
  }
}

输出结果：

INFO : org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@73a8dfcc: startup date [Wed Sep 26 10:31:21 CST 2018]; root of context hierarchy
INFO : org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loading XML bean definitions from class path resource [spring/spring-redis-list.xml]
删除list成功
1
3
4
第一个节点:node1
list中的总数为：4
leftPopNode:node1
rightPopNode:node4
3
4
5
6
节点：head
节点：before_node
节点：node2
节点：after_node
节点：node3
节点：end
9
3
节点：new_head_value
节点：before_node
节点：node2
节点：after_node
节点：node3
节点：end
---------------------
节点：new_head_value
节点：before_node
节点：node2

有些命令 Spring 所提供的 RedisTemplate 并不能支持，比如 linsert 命令。可以使用更为底层的方法去操作，如下

redisTemplate.getConnectionFactory().getConnection()
          .lInsert(key.getBytes("utf-8"), RedisListCommands.Position.AFTER, "node2".getBytes("utf-8"), "after_node".getBytes("utf-8"));

在多值操作的时候，往往会使用 list 进行封装，比如 leftPushAll 方法，对于很大的 list的操作需要注意性能，比如 remove 这样的操作，在大的链表中会消耗 Redis 系统很多的性能。

链表的阻塞命令

上面的这些操作链表的命令都是进程不安全的，因为当我们操作这些命令的时候，其他 Redis 的客户端也可能操作同一个链表，这样就会造成并发数据安全和一致性的问题，尤其是当你操作一个数据量不小的链表结构时，常常会遇到这样的问题。 Redis 提供了链表的阻塞命令，它们在运行的时候，会给链表加锁，以保证操作链表的命令安全性.

当使用这些命令时， Redis 就会对对应的链表加锁，加锁的结果就是其他的进程不能再读取或者写入该链表，只能等待命令结束。加锁的好处可以保证在多线程并发环境中数据的一致性，保证一些重要数据的一致性，比如账户的金额、商品的数量。不过在保证这些的同时也要付出其他线程等待、线程环境切换等代价，这将使得系统的并发能力下

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> LPUSH list node1 node2 node3 node4 node5
(integer) 5
127.0.0.1:6379> LRANGE list 0 4
1) "node5"
2) "node4"
3) "node3"
4) "node2"
5) "node1"
127.0.0.1:6379> BLPOP list 2
1) "list"
2) "node5"
127.0.0.1:6379> LRANGE list 0 4
1) "node4"
2) "node3"
3) "node2"
4) "node1"
127.0.0.1:6379> BRPOP list 3
1) "list"
2) "node1"
127.0.0.1:6379> LPUSH list2 data1 data2 data3
(integer) 3
127.0.0.1:6379> RPOPLPUSH list list2
"node2"
127.0.0.1:6379> BRPOPLPUSH list list2 3
"node3"
127.0.0.1:6379> LRANGE list 0 10
1) "node4"
127.0.0.1:6379> LRANGE list2 0 10
1) "node3"
2) "node2"
3) "data3"
4) "data2"
5) "data1"

在实际的项目中，虽然阻塞可以有效保证了数据的一致性，但是阻塞就意味着其他进程的等待， CPU 需要给其他线程挂起、恢复等操作，更多的时候我们希望的并不是阻塞的处理请求，所以这些命令在实际中使用得并不多.

使用Spring 操作Redis 链表阻塞命令

package com.artisan.redis.baseStructure.list;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
public class SpringRedisBlockListDemo {
  private static final String KEY1 = "list1";
  private static final String KEY2 = "list2";
  public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:spring/spring-redis-list.xml");
    RedisTemplate redisTemplate = ctx.getBean(RedisTemplate.class);
    // 清空操作
    redisTemplate.delete(KEY1);
    redisTemplate.delete(KEY2);
    // 127.0.0.1:6379> LPUSH list node1 node2 node3 node4 node5
    // (integer) 5
    List<String> list = new ArrayList<String>();
    for (int i = 1; i <= 5; i++) {
      list.add("node" + i);
    }
    redisTemplate.opsForList().leftPushAll(KEY1, list);
    scanList(redisTemplate, KEY1, 0, 4);
    System.out.println("---------------------------");
    // 127.0.0.1:6379> BLPOP list 2
    // 1) "list"
    // 2) "node5"
    // Spring 使用参数超时时间作为阻塞命令区分，等价于 blpop 命令，并且可以设置时间参数
    String lefpPodNode = (String) redisTemplate.opsForList().leftPop(KEY1, 2, TimeUnit.SECONDS);
    System.out.println("leftPopNode:" + lefpPodNode);
    System.out.println("---------------------------");
    // 127.0.0.1:6379> LRANGE list 0 4
    // 1) "node4"
    // 2) "node3"
    // 3) "node2"
    // 4) "node1"
    scanList(redisTemplate, KEY1, 0, 4);
    System.out.println("---------------------------");
    // 127.0.0.1:6379> BRPOP list 3
    // 1) "list"
    // 2) "node1"
    // Spring 使用参数超时时间作为阻塞命令区分，等价于 brpop 命令，并且可以设置时间参数
    System.out.println("rightPopNode:" + redisTemplate.opsForList().rightPop(KEY1, 3, TimeUnit.SECONDS));
    System.out.println("---------------------------");
    // 127.0.0.1:6379> LRANGE list 0 4
    // 1) "node4"
    // 2) "node3"
    // 3) "node2"
    scanList(redisTemplate, KEY1, 0, 4);
    System.out.println("---------------------------");
    // 127.0.0.1:6379> LPUSH list2 data1 data2 data3
    // (integer) 3
    List<String> list2 = new ArrayList<String>();
    for (int i = 3; i >= 1; i--) {
      list2.add("data" + i);
    }
    System.out.println(redisTemplate.opsForList().leftPushAll(KEY2, list2));
    System.out.println("---------------------------");
    // 127.0.0.1:6379> RPOPLPUSH list list2
    // "node2"
    // 相当于 rpoplpush 命令，弹出 list1最右边的节点，插入到 list2 最左边
    String value2 = (String) redisTemplate.opsForList().rightPopAndLeftPush(KEY1, KEY2);
    System.out.println("rightPopAndLeftPush:" + value2);
    System.out.println("-------------------");
    // 127.0.0.1:6379> BRPOPLPUSH list list2 3
    // "node3"
    // 相当于 brpoplpush 命令，注意在 Spring 中使用超时参数区分
    String value3 = (String) redisTemplate.opsForList().rightPopAndLeftPush(KEY1, KEY2, 3, TimeUnit.SECONDS);
    System.out.println("rightPopAndLeftPush:" + value3);
    System.out.println("-------------------");
    // 127.0.0.1:6379> LRANGE list 0 10
    // 1) "node4"
    scanList(redisTemplate, KEY1, 0, 10);
    System.out.println("-------------------");
    // 127.0.0.1:6379> LRANGE list2 0 10
    // 1) "node3"
    // 2) "node2"
    // 3) "data3"
    // 4) "data2"
    // 5) "data1"
    scanList(redisTemplate, KEY2, 0, 10);
  }
  private static void scanList(RedisTemplate redisTemplate, String key, int begin, int end) {
    List<String> data = redisTemplate.opsForList().range(key, begin, end);
    for (String string : data) {
      System.out.println("节点：" + string);
    }
  }
}

输出

INFO : org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@73a8dfcc: startup date [Wed Sep 26 12:53:56 CST 2018]; root of context hierarchy
INFO : org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loading XML bean definitions from class path resource [spring/spring-redis-list.xml]
节点：node5
节点：node4
节点：node3
节点：node2
节点：node1
---------------------------
leftPopNode:node5
---------------------------
节点：node4
节点：node3
节点：node2
节点：node1
---------------------------
rightPopNode:node1
---------------------------
节点：node4
节点：node3
节点：node2
---------------------------
3
---------------------------
rightPopAndLeftPush:node2
-------------------
rightPopAndLeftPush:node3
-------------------
节点：node4
-------------------
节点：node3
节点：node2
节点：data1
节点：data2
节点：data3

上面展示了 Redis 关于链表的阻塞命令，在 Spring 中它和非阻塞命令的方法是一致的，只是它会通过超时参数进行区分，而且我们还可以通过方法设置时间的单位。注意，它是阻塞的命令，在多线程的环境中，它能在一定程度上保证数据的一致而性能却不佳。

注意

使用 Spring 提供的 RedisTemplate 去展示多个命令可以学习到如何使用 RedisTemplate 操作 Redis 。实际工作中并不是那么用的，因为每一个操作会尝试从连接池里获取一个新的 Redis 连接，多个命令应该使用SessionCallback 接口进行操作。

代码

代码托管到了 https://github.com/yangshangwei/redis_learn

Redis-05Redis数据结构--链表( linked-list)

概述

Redis 关于链表的命令

使用 Spring 操作 Redis 链表命令

链表的阻塞命令

使用Spring 操作Redis 链表阻塞命令

注意

代码

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Redis-05Redis数据结构--链表( linked-list)

概述

Redis 关于链表的命令

使用 Spring 操作 Redis 链表命令

链表的阻塞命令

使用Spring 操作Redis 链表阻塞命令

注意

代码

热门文章

最新文章

相关课程

相关电子书

相关实验场景