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

最新推荐文章于 2023-08-23 08:00:00 发布

小小工匠

最新推荐文章于 2023-08-23 08:00:00 发布

阅读量1w

点赞数 3

分类专栏：【Redis-入门到精通】文章标签： redis链表

本文链接：https://blog.csdn.net/yangshangwei/article/details/82792672

版权

【Redis-入门到精通】同时被 2 个专栏收录

34 篇文章 12 订阅

订阅专栏

Redis手札

26 篇文章 4 订阅

订阅专栏

文章目录

概述
Redis 关于链表的命令
使用 Spring 操作 Redis 链表命令
链表的阻塞命令
使用Spring 操作Redis 链表阻塞命令
注意
代码

概述

链表结构是 Redis 中一个常用的结构，它可以存储多个字符串
它是有序的
能够存储2的32次方减一个节点（超过 40 亿个节点）
Redis 链表是双向的，因此即可以从左到右，也可以从右到左遍历它存储的节点
链表结构查找性能不佳，但插入和删除速度很快

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

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

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

Redis 关于链表的命令

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

在这里插入图片描述

命令	说明	备注
lpush key node1 [node2.]…	把节点 node1 加入到链表最左边	如果是 node 1 、 node2…noden 这样加入，那么链表开头从左到右顺序是 noden…node2 、 node1
rpush key node1 [node2]…	把节点 node1 加入到链表最右边	如果是 node 1 、 node2…noden 这样加入，那么链表开头从左到右顺序是node 1 、 node2…noden
lindex key index	读取下标为 index 的节点	返回节点字符串，从 0 开始算
llen key	求链表的长度	返回链表节点数
lpop key	删除左边第一个节点，并将其返回
rpop key	删除右边第一个节点，并将其返回
linsert key before/after pivot node	插入一个节点 node，并且可以指定在值为 pivot的节点的前面（ before ）或者后面（ after )	如果 list 不存在，则报销：如果没有值为对应 pivot 的，也会插入失败返回-1
lpushx list node	如果存在 key 为 list 的链表，则插入节点 node, 并且作为从左到右的第一个节点	如果 list 不存在，则失败
rpushx list node	如果存在 key 为 list 的链表，则插入节点 node, 并且作为从左到右的最后一个节点	如果 list 不存在，则失败
lrange list start end	获取链表 list 从 start 下标到 end 下标的节点值	包含 start 和 end 下标的值
lrem list count value	如果 count 为 0，则删除所有值等于 value 的节点：如果 count 不是 0，则先对 count 取绝对值，假设记为 abs，然后从左到右删除不大于 abs 个等于 value 的节点	注意， count 为整数，如l果是负数，则Redis会先求取其绝对值，然后传递到后台操作
lset key index node	设置列表下标为 index 的节点的值为 node
ltrim key start stop	修剪链表，只保留从 start 到 stop 的区间的节点，其余的都删除掉	包含 start 和 end 的下标的节点会保留

对于很多个节点同时操作的，需要考虑其花费的时间，链表数据结构对于查找而言并不适合于大数据。我们需要考虑插入和删除内容的大小，因为这将是十分消耗性能的命令，会导致 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 提供了链表的阻塞命令，它们在运行的时候，会给链表加锁，以保证操作链表的命令安全性.

命令	说明	备注
blpop key timeout [node2.]…	移出并获取列表的第一个元索，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止	相对于 lpop 命令，它的操作是进程安全的
brpop key timeout [node2.]…	移出并获取列表的最后一个元索，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止	相对于 lpop 命令，它的操作是进程安全的
rpoplpush key src dest	按从左到右的顺序，将一个链表的最后一个元素移除，并插入到目标链表的最左边	不能设置超时间
brpoplpush key src dest timeout	按从左到右的顺序，将一个链表的最后一个元素移除，并插入到目标链表的最左边，并可以设置届时时间	可以设置超时时间

当使用这些命令时， 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

小小工匠

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Redis-05Redis数据结构--链表( linked-list)

文章目录概述Redis 关于链表的命令概述链表结构是 Redis 中一个常用的结构，它可以存储多个字符串它是有序的能够存储2的32次方减一个节点（超过 40 亿个节点）Redis 链表是双向的，因此即可以从左到右，也可以从右到左遍历它存储的节点链表结构查找性能不佳，但插入和删除速度很快由于是双向链表，所以只能够从左到右，或者从右到左地访问和操作链表里面的数据节点。但是使用链表...
复制链接

扫一扫