Redis速学

2024-03-01 01:20
文章标签 redis 速学

本文主要是介绍Redis速学，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、介绍Redis

基本概念和特点

Redis是一个开源的内存数据库，它主要用于数据缓存和持久化。其数据存储在内存中，这使得它具有非常快的读写速度。Redis支持多种数据结构，包括字符串、哈希、列表、集合和有序集合，这使得它非常灵活，能够适应各种不同的数据处理需求。此外，Redis也支持数据持久化，可以将数据保存到磁盘上，确保数据不会因服务器重启而丢失。

优势和适用场景

Redis的优势在于快速、灵活、丰富的数据结构和持久化功能。适用场景包括但不限于：

  • 数据缓存：用于加速对数据库或外部API的访问，减轻后端系统压力。
  • 会话缓存：用于存储用户会话信息，提高网站性能和扩展性。
  • 消息队列：实现发布/订阅模式，处理异步任务和事件驱动架构。
  • 实时分析：存储和处理实时数据，如统计数据、计数器等。
  • 计数器和排行榜：用于实时计数和排名功能。

演示安装和配置Redis

演示如何安装和配置Redis可以涉及以下步骤：

  1. 下载和安装Redis软件包
  2. 配置Redis实例，包括端口设置、内存限制、持久化选项等
  3. 启动Redis服务器
  4. 使用命令行工具连接到Redis并执行一些基本操作，如设置键值对、操作数据结构等。

二、Redis数据结构及其适用场景

字符串

  • 设置字符串：使用命令 SET key value，例如 SET user:1000:name "Alice"。
  • 获取字符串：使用命令 GET key，例如 GET user:1000:name。
  • 删除字符串：使用命令 DEL key，例如 DEL user:1000:name。
  • 适用场景：用于缓存用户会话信息、存储临时数据等。

哈希

  • 添加哈希字段：使用命令 HSET key field value，例如 HSET user:1000 age 30。
  • 获取哈希字段：使用命令 HGET key field，例如 HGET user:1000 age。
  • 删除哈希字段：使用命令 HDEL key field，例如 HDEL user:1000 age。
  • 适用场景：存储用户信息、对象属性，如用户资料、商品信息等。

列表

  • 在列表头部插入元素：使用命令 LPUSH key value，例如 LPUSH news:latest "New article"。
  • 在列表尾部插入元素：使用命令 RPUSH key value，例如 RPUSH news:latest "Another article"。
  • 删除列表元素：使用命令 LPOP key 或 RPOP key，例如 LPOP news:latest。
  • 适用场景：消息队列、新闻推送、最新动态等。

集合

  • 添加集合元素：使用命令 SADD key member，例如 SADD tags:redis "database"。
  • 获取集合元素：使用命令 SMEMBERS key，例如 SMEMBERS tags:redis。
  • 删除集合元素：使用命令 SREM key member，例如 SREM tags:redis "database"。
  • 适用场景：标签系统、唯一值管理、好友列表等。

有序集合

  • 添加有序集合元素：使用命令 ZADD key score member，例如 ZADD leaderboard 1000 "PlayerA"。
  • 获取有序集合元素：使用命令 ZRANGE key start stop，例如 ZRANGE leaderboard 0 9。
  • 删除有序集合元素：使用命令 ZREM key member，例如 ZREM leaderboard "PlayerA"。
  • 适用场景：排行榜、范围查询、按分数排序的数据存储。

三、Redis持久化

Redis提供了两种持久化方式：快照（snapshot）和日志（journal）持久化。这些机制可以确保在Redis服务器重启时数据不会丢失。

#1. 快照持久化

快照持久化通过将当前数据集的副本写入磁盘来实现持久化。Redis会周期性地将数据集快照写入磁盘。当Redis重启时，可以通过加载最近的快照来恢复数据。

配置快照持久化

在Redis配置文件中，可以通过以下设置配置快照持久化：

save 900 1     # 在900秒（15分钟）内，如果至少有1个键被修改，则保存快照
save 300 10    # 在300秒（5分钟）内，如果至少有10个键被修改，则保存快照
save 60 10000  # 在60秒内，如果至少有10000个键被修改，则保存快照

上述配置表示了在不同时间段内触发快照保存的条件。可以根据实际情况调整这些设置。

2. 日志持久化

日志持久化（也称为AOF持久化）记录了服务器接收到的所有写操作命令，以此来重放这些命令来恢复原始数据集。AOF持久化可以确保更高的数据安全性，但通常会占用更多的磁盘空间。

配置日志持久化

在Redis配置文件中，可以通过以下设置启用AOF持久化：

appendonly yes     # 启用AOF持久化

还可以设置AOF持久化的文件名和重写策略等参数。

管理持久化功能

除了配置文件之外，可以使用Redis的命令行工具或者客户端连接来管理持久化功能。例如，可以手动触发快照保存或者AOF重写。

  • 手动触发快照保存：使用 SAVE 命令或 BGSAVE 命令。
  • 手动触发AOF重写：使用 BGREWRITEAOF 命令。

通过了解和配置Redis的持久化功能，可以确保数据在重启或者故障恢复时不会丢失，并且可以根据需求来调整持久化机制以平衡数据安全和性能。

四、Redis高级特性

1. 发布/订阅功能

Redis的发布/订阅功能允许客户端订阅频道并接收发布到该频道的消息。这种模式使得多个客户端可以订阅感兴趣的频道并接收相关信息，从而构建实时通信和消息传递系统。

使用发布/订阅功能

  • 订阅频道：客户端可以使用 SUBSCRIBE 命令来订阅一个或多个频道，以接收相关消息。
    SUBSCRIBE channel
  • 发布消息：客户端可以使用 PUBLISH 命令向指定的频道发布消息。
    PUBLISH channel message

2. 事务支持

Redis的事务支持通过 MULTI、EXEC、DISCARD 和 WATCH 等命令来实现。这使得客户端可以将多个命令打包成一个事务，然后一次性、原子性地执行这些命令。

使用事务

  • 开启事务：使用 MULTI 命令来开启一个事务块。
  • 添加命令：在事务块内，添加要执行的命令。
  • 执行事务：使用 EXEC 命令来执行事务中的所有命令，或者使用 DISCARD 命令来取消事务。
  • 监视键：使用 WATCH 命令来监视一个或多个键，如果在事务执行过程中这些键被修改，则事务将被取消。

3. 构建高级应用

这些高级特性可以用于构建诸如实时消息系统、事务性操作和分布式锁等高级应用程序。例如，可以使用发布/订阅功能构建实时聊天应用，使用事务来确保多个命令的原子性执行，或者使用WATCH来实现分布式锁的功能。

（1）实时消息系统

利用Redis的发布/订阅功能，可以构建实时消息系统。例如，假设我们有一个在线聊天应用，用户可以订阅属于他们的聊天频道，当其他用户发送消息时，消息将被发布到相应的频道，而订阅该频道的用户将实时接收到消息。这种模式可以实现实时通信，例如即时聊天和实时通知等功能。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub;public class RealTimeMessagingSystem {public static void main(String[] args) {// 订阅者new Thread(() -> {Jedis jedis = new Jedis("localhost");jedis.subscribe(new JedisPubSub() {@Overridepublic void onMessage(String channel, String message) {System.out.println("Received message: " + message + " from channel: " + channel);}}, "real-time-channel");jedis.close();}).start();// 发布者new Thread(() -> {Jedis jedis = new Jedis("localhost");try {Thread.sleep(1000); // 等待订阅者准备好jedis.publish("real-time-channel", "Hello, Redis!");} catch (InterruptedException e) {e.printStackTrace();} finally {jedis.close();}}).start();}
}

（2） 事务性操作

Redis的事务支持可以用于执行一系列命令，要么全部执行，要么全部不执行，具有原子性。这在需要确保多个命令按照特定顺序执行或者一起执行时非常有用。举例来说，假设我们需要在银行应用中从一个账户转账到另一个账户。我们可以使用Redis的事务性操作来确保扣款和存款两个操作要么同时成功，要么同时失败，从而避免出现数据不一致的情况。Redis 事务可以通过 MULTI、EXEC、DISCARD 和 WATCH 命令来实现。事务保证了一系列命令的原子性执行。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;public class TransactionalOperations {public static void main(String[] args) {Jedis jedis = new Jedis("localhost");// 开始事务Transaction t = jedis.multi();try {t.set("foo", "bar");t.set("hello", "world");// 执行事务t.exec();} catch (Exception e) {// 如果出现异常，放弃事务t.discard();} finally {jedis.close();}}
}

（3）分布式锁

Redis的原子性操作和分布式特性使其成为构建分布式锁的理想选择。通过利用Redis的SETNX命令（SET if Not eXists），可以在分布式环境中实现互斥锁。这在需要确保某个操作在分布式系统中只能被一个实例执行时非常有用，比如控制对共享资源的访问。

分布式系统是由多台计算机组成的系统，这些计算机通过网络相互连接并协同工作，以完成共同的任务和目标。在分布式系统中，各个计算机节点可以独立运行，并通过消息传递或共享状态来协调彼此的行为，从而实现更大规模的计算和处理能力。
关键特点包括：

  1. 并行处理: 分布式系统能够并行处理任务，通过将任务分配给不同的节点，从而提高整体系统的处理能力和性能。
  2. 容错性: 分布式系统通常具有一定的容错能力，即使某个节点出现故障，系统仍然能够继续运行。
  3. 可伸缩性: 分布式系统通常具有良好的可伸缩性，可以通过增加节点来扩展系统的处理能力。
  4. 资源共享: 分布式系统中的节点可以共享资源（如存储、计算资源等），从而实现更高效的资源利用。
  5. 分布式存储: 分布式系统通常具有分布式存储的能力，可以将数据分布存储在不同的节点上，以实现更高的数据可靠性和容量。

分布式锁是一种用于在分布式系统中实现互斥访问的技术。在分布式系统中，多个节点可能需要同时访问共享资源或执行某个关键操作，因此需要一种机制来确保在任意时刻只有一个节点能够访问该资源或执行该操作，以避免数据不一致或竞争条件的发生。
分布式锁通常用于以下场景：

  1. 避免资源冲突: 当多个节点需要访问共享资源（如数据库、文件、缓存等）时，分布式锁可以确保同一时刻只有一个节点能够访问该资源，从而避免冲突和数据不一致。
  2. 防止重复操作: 在某些情况下，需要确保某个操作只能被执行一次，分布式锁可以用来保证该操作在分布式系统中的幂等性。

常见的实现分布式锁的方式包括利用分布式存储系统（如Redis、ZooKeeper等）来协调各个节点之间的锁状态，以及利用乐观锁和悲观锁等技术来实现分布式环境下的互斥访问。

SETNX 是 Redis 中的一条命令，用于设置一个键的值，当且仅当该键不存在时。SETNX 是 “SET if Not eXists” 的缩写。

其语法为：

SETNX key value

其中 key 是要设置的键，value 是要设置的值。

如果 key 不存在，则会将 key 设置为 value，并返回 1，表示设置成功。如果 key 已经存在，则不做任何操作，返回 0，表示设置失败。

这个命令通常用于实现分布式锁，因为它可以确保只有一个客户端能够成功地设置某个键，从而实现互斥操作。

import redis.clients.jedis.Jedis;public class DistributedLock {public static void main(String[] args) {Jedis jedis = new Jedis("localhost");// 尝试获取锁String lockKey = "lock:key";long acquired = jedis.setnx(lockKey, String.valueOf(System.currentTimeMillis()));if (acquired == 1) {try {// 锁的业务逻辑System.out.println("Lock acquired!");// ...} finally {// 释放锁jedis.del(lockKey);}} else {System.out.println("Could not acquire lock!");}jedis.close();}
}

在这个分布式锁的例子中，我们使用 setnx 命令尝试设置一个锁。如果返回值是 1，表示我们成功获取了锁。在锁的业务逻辑执行完毕后，我们通过删除键来释放锁。如果返回值不是 1，表示锁已经被其他进程持有。

请注意，这个分布式锁的实现是最基本的，它没有处理锁的超时问题。在实际应用中，你可能需要使用更复杂的模式，比如 Redlock 算法，或者使用 Redisson 这样的库，它提供了更加健壮的分布式锁实现。

五、Redis在实际应用中的使用

首先，确保Java 项目中包含了 Redis 客户端库，比如 Jedis。可以通过 Maven 或者 Gradle 将其添加到你的项目依赖中。

Maven 依赖示例

<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>最新版本</version>
</dependency>

Redis作为缓存系统的最佳实践

Redis 作为缓存系统的最佳实践包括以下方面：

  1. 缓存热点数据：将经常访问的数据缓存在 Redis 中，以减轻后端数据库的压力，提高数据访问速度。

  2. 选择合适的数据结构：根据实际需求选择合适的数据结构，如字符串、哈希、列表、集合、有序集合等，以最大程度地发挥 Redis 的性能优势。

  3. 设置合理的过期时间：对于缓存的数据，根据数据的更新频率和重要性，设置合理的过期时间，避免缓存数据过期而导致的数据不一致性。

  4. 使用预热机制：在系统启动或重启时，通过预热机制将热点数据加载到缓存中，避免大量请求直接打到后端数据库。

  5. 实现缓存穿透保护：采用布隆过滤器或在缓存中存储空对象等方式，防止缓存穿透，即针对不存在的数据频繁请求导致的直接访问后端数据库。

  6. 考虑高可用和扩展性：使用 Redis 的主从复制和集群功能，确保缓存系统的高可用性和扩展性。

import redis.clients.jedis.Jedis;public class RedisCacheExample {public static void main(String[] args) {// 连接到 RedisJedis jedis = new Jedis("localhost", 6379);// 假设我们要缓存用户的个人资料String userKey = "user:12345";jedis.hset(userKey, "name", "Alice");jedis.hset(userKey, "age", "30");jedis.hset(userKey, "email", "alice@example.com");// 设置缓存过期时间为 1 小时jedis.expire(userKey, 3600);// 从缓存中获取用户的个人资料System.out.println(jedis.hgetAll(userKey));// 模拟缓存过期try {Thread.sleep(3601 * 1000); // 注意 Java 中的 sleep 方法接受的是毫秒} catch (InterruptedException e) {e.printStackTrace();}System.out.println(jedis.hgetAll(userKey)); // 这将显示一个空的 Map，因为缓存已经过期// 关闭连接jedis.close();}
}

将Redis用作消息中间件，实现队列和发布/订阅模式

  1. 队列：Redis 的列表数据结构非常适合用作队列。通过 LPUSH 和 RPOP 命令，可以将消息推入队列并从队列中弹出消息。这种方式可以实现简单的任务队列，用于异步处理任务或消息传递。

  2. 发布/订阅模式：Redis 支持发布/订阅模式，可以通过 PUBLISH 命令发布消息，而订阅者可以通过 SUBSCRIBE 命令订阅指定的频道，从而接收发布者发送的消息。这种模式非常适合实现实时消息推送、事件通知等功能。

  3. 保证消息可靠性：在使用 Redis 作为消息中间件时，需要考虑消息的可靠性。可以通过持久化机制、ACK 确认机制等方式来确保消息的可靠性传递。

  4. 消息过期和重试机制：针对消息的过期处理和重试机制，可以在应用层面或者使用 Redis 提供的过期设置来处理。

  5. 扩展性和负载均衡：使用 Redis 集群或者主从复制机制，可以实现消息中间件的扩展和负载均衡，确保系统的稳定性和性能。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub;public class RedisPubSubExample {public static void main(String[] args) {// 启动订阅者线程Thread subscriberThread = new Thread(() -> {Jedis jedis = new Jedis("localhost", 6379);jedis.subscribe(new JedisPubSub() {@Overridepublic void onMessage(String channel, String message) {System.out.println("Received: " + message);}}, "channel");jedis.close();});subscriberThread.start();// 启动发布者线程Thread publisherThread = new Thread(() -> {Jedis jedis = new Jedis("localhost", 6379);try {while (true) {jedis.publish("channel", "some message");Thread.sleep(1000);}} catch (InterruptedException e) {e.printStackTrace();} finally {jedis.close();}});publisherThread.start();}
}

综上所述，Redis 作为消息中间件可以提供可靠的消息传递和发布/订阅功能，同时作为队列系统可以支持异步任务处理和消息传递，为实际应用提供了灵活而强大的功能支持。

第六讲：性能优化和故障排除

  • 分析Redis的性能优化策略，包括内存管理和命令优化
  • 演示如何排除常见的Redis故障和性能问题

Redis 的性能优化通常涉及内存管理、命令优化、配置调整和故障排除。以下是一些关键策略和示例：

内存管理

使用合适的数据类型：选择正确的数据类型可以大幅节省内存。例如，使用哈希类型存储对象而不是字符串类型。

  1. 内存淘汰策略：当内存使用接近限制时，Redis 提供了多种淘汰策略，如 volatile-lru、allkeys-lru、volatile-ttl 等。根据你的应用场景选择合适的策略。

  2. 内存优化配置：使用 maxmemory 配置项来设置 Redis 最大内存使用量，超过这个限制时将触发淘汰策略。

命令优化

  1. 避免大键操作：大键操作可能会阻塞 Redis，使用 SCAN 命令代替 KEYS，使用 HSCAN、SSCAN、ZSCAN 来迭代大集合。

  2. 批量操作：使用 MGET、MSET 或 pipeline 来减少网络往返次数。

  3. Lua 脚本：使用 Lua 脚本可以将多个命令封装在服务器端执行，减少网络延迟。

配置调整

  1. 持久化策略：根据需要选择 RDB 快照、AOF 日志或两者结合。调整 save 配置和 appendfsync 选项以平衡性能和数据安全。

  2. 复制和分片：通过主从复制提高数据的可用性。使用 Redis 集群或分片来分散负载。

故障排除和性能问题

  1. 监控：使用 INFO 命令或 Redis 监控工具来跟踪性能指标。

  2. 慢查询日志：检查 SLOWLOG 获取执行缓慢的命令。

  3. 配置优化：调整 tcp-keepalive、timeout、tcp-backlog 等网络相关配置。

  4. 硬件升级：如果性能瓶颈是由硬件限制，可能需要升级 CPU、内存或使用更快的存储。

下面是一些 Java 代码示例，演示如何使用 Jedis 客户端来执行上述操作：

import redis.clients.jedis.Jedis;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;public class RedisOptimizationExample {public static void main(String[] args) {Jedis jedis = new Jedis("localhost");// 使用 SCAN 命令代替 KEYSString cursor = "0";ScanParams scanParams = new ScanParams().count(100);do {ScanResult<String> scanResult = jedis.scan(cursor, scanParams);cursor = scanResult.getCursor();scanResult.getResult().forEach(key -> {// 处理每个键System.out.println(key);});} while (!cursor.equals("0"));// 检查慢查询日志System.out.println("Slowlog: " + jedis.slowlogGet());// 获取内存使用信息System.out.println("Memory Info: " + jedis.info("memory"));// 获取配置参数System.out.println("Config maxmemory: " + jedis.configGet("maxmemory"));// 设置内存淘汰策略为 volatile-lrujedis.configSet("maxmemory-policy", "volatile-lru");

故障排除

  1. 内存问题：如果 Redis 实例消耗内存过多，可以通过 INFO memory 命令查看内存使用详情。如果发现特定类型的键占用了过多内存，可能需要优化这些键的使用或数据结构。

  2. CPU 使用率高：高 CPU 使用率通常意味着 Redis 正在处理大量的请求或执行复杂的命令。可以通过 INFO CPU 查看 CPU 统计信息。如果 CPU 使用率持续高，可能需要优化命令或考虑增加更多的 Redis 实例进行负载均衡。

  3. 磁盘 I/O 问题：如果使用 AOF 持久化，磁盘 I/O 可能成为瓶颈。可以通过调整 appendfsync 配置项来优化。例如，设置为 everysec 可以平衡性能和数据安全。

  4. 网络瓶颈：如果 Redis 实例和客户端之间的网络延迟高，可以考虑将 Redis 实例移动到离客户端更近的位置，或者优化网络配置。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;public class RedisTroubleshootingExample {public static void main(String[] args) {// 创建 JedisPool 来管理连接JedisPoolConfig poolConfig = new JedisPoolConfig();poolConfig.setMaxTotal(128); // 设置最大连接数JedisPool jedisPool = new JedisPool(poolConfig, "localhost");try (Jedis jedis = jedisPool.getResource()) {// 获取内存使用信息String memoryInfo = jedis.info("memory");System.out.println("Memory Info: " + memoryInfo);// 获取 CPU 使用信息String cpuInfo = jedis.info("cpu");System.out.println("CPU Info: " + cpuInfo);// 获取并设置慢查询日志的阈值String slowlogMaxLen = jedis.configGet("slowlog-max-len").get(1);System.out.println("Current slowlog-max-len: " + slowlogMaxLen);jedis.configSet("slowlog-max-len", "128");// 获取慢查询日志System.out.println("Slowlog: " + jedis.slowlogGet());// 检查网络延迟System.out.println("Ping: " + jedis.ping());}// 关闭连接池jedisPool.close();}
}

在这个示例中，我们使用了 JedisPool 来管理 Redis 连接，这是生产环境中推荐的做法，因为它可以重用连接，减少连接建立和销毁的开销。我们还展示了如何获取内存和 CPU 的使用信息，如何配置和检查慢查询日志，以及如何检查网络延迟。

请注意，这些代码示例仅用于演示如何使用 Jedis 客户端来获取 Redis 的性能信息和进行一些基本的配置。在实际的生产环境中，你可能需要结合监控工具和日志分析工具来进行更深入的性能分析和故障。

这篇关于Redis速学的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/760734。

相关文章

零基础学习Redis(10) -- zset类型命令使用

零基础学习Redis(10) -- zset类型命令使用

zset是有序集合，内部除了存储元素外，还会存储一个score，存储在zset中的元素会按照score的大小升序排列，不同元素的score可以重复，score相同的元素会按照元素的字典序排列。 1. zset常用命令 1.1 zadd  zadd key [NX | XX] [GT | LT]   [CH] [INCR] score member [score member ...]
阅读更多...
Redis中使用布隆过滤器解决缓存穿透问题

Redis中使用布隆过滤器解决缓存穿透问题

一、缓存穿透(失效)问题 缓存穿透是指查询一个一定不存在的数据，由于缓存中没有命中，会去数据库中查询，而数据库中也没有该数据，并且每次查询都不会命中缓存，从而每次请求都直接打到了数据库上，这会给数据库带来巨大压力。 二、布隆过滤器原理 布隆过滤器（Bloom Filter）是一种空间效率很高的随机数据结构，它利用多个不同的哈希函数将一个元素映射到一个位数组中的多个位置，并将这些位置的值置
阅读更多...
Lua 脚本在 Redis 中执行时的原子性以及与redis的事务的区别

Lua 脚本在 Redis 中执行时的原子性以及与redis的事务的区别

在 Redis 中，Lua 脚本具有原子性是因为 Redis 保证在执行脚本时，脚本中的所有操作都会被当作一个不可分割的整体。具体来说，Redis 使用单线程的执行模型来处理命令，因此当 Lua 脚本在 Redis 中执行时，不会有其他命令打断脚本的执行过程。脚本中的所有操作都将连续执行，直到脚本执行完成后，Redis 才会继续处理其他客户端的请求。 Lua 脚本在 Redis 中原子性的原因
阅读更多...
laravel框架实现redis分布式集群原理

laravel框架实现redis分布式集群原理

在app/config/database.php中配置如下： 'redis' => array('cluster' => true,'default' => array('host' => '172.21.107.247','port' => 6379,),'redis1' => array('host' => '172.21.107.248','port' => 6379,),) 其中cl
阅读更多...
Redis的rehash机制

Redis的rehash机制

在Redis中，键值对（Key-Value Pair）存储方式是由字典（Dict）保存的，而字典底层是通过哈希表来实现的。通过哈希表中的节点保存字典中的键值对。我们知道当HashMap中由于Hash冲突（负载因子）超过某个阈值时，出于链表性能的考虑，会进行Resize的操作。Redis也一样。 在redis的具体实现中，使用了一种叫做渐进式哈希(rehashing)的机制来提高字典的缩放效率，避
阅读更多...
【吊打面试官系列-Redis面试题】说说 Redis 哈希槽的概念？

【吊打面试官系列-Redis面试题】说说 Redis 哈希槽的概念？

大家好，我是锋哥。今天分享关于 【说说 Redis 哈希槽的概念？】面试题，希望对大家有帮助； 说说 Redis 哈希槽的概念？ Redis 集群没有使用一致性 hash,而是引入了哈希槽的概念，Redis 集群有 16384 个哈希槽，每个 key 通过 CRC16 校验后对 16384 取模来决定放置哪个槽， 集群的每个节点负责一部分 hash 槽。
阅读更多...
Redis地理数据类型GEO

Redis地理数据类型GEO

通常要计算两个地理位置的距离不是很方便，这里可以直接通过Redis提供的GEO操作来完成地理位置相关的计算 1）添加地理位置 语法：geoadd key longitude latitude member [longitude latitude member] ...字段说明：key：存放地理位置的集合名称longitude：地理坐标的经度latitude：地理坐标的纬度member：表示这
阅读更多...
Redis-主从集群

Redis-主从集群

主从架构 单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，就需要搭建主从集群，实现读写分离。 主从数据同步原理 全量同步 主从第一次建立连接时，会执行全量同步，将master节点的所有数据都拷贝给slave节点，流程： 判断是否是第一次同步，如果是，返回版本信息（replication id 和offset），将salve节点的版本信息变为master的
阅读更多...
Redis安装使用总结

Redis安装使用总结

一、下载安装 从 github 下载：https://github.com/MSOpenTech/redis/releases 或者 https://github.com/ServiceStack/redis-windows 解压缩，如图： 二、配置 打开redis.windows-sevice.conf文件， 2.1 绑定ip：搜索127.0.0.1 ，发现bind 127.0.0.
阅读更多...
面对Redis数据量庞大时的应对策略

面对Redis数据量庞大时的应对策略

面对Redis数据量庞大时的应对策略，我们可以从多个维度出发，包括数据分片、内存优化、持久化策略、使用集群、硬件升级、数据淘汰策略、以及数据结构选择等。以下是对这些策略的详细探讨： 一、数据分片（Sharding） 当Redis数据量持续增长，单个实例的处理能力可能达到瓶颈。此时，可以通过数据分片将数据分散存储到多个Redis实例中，以实现水平扩展。分片的主要策略包括： 一致性哈希：使用一
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2