Redis

最新推荐文章于 2024-01-12 09:14:58 发布
最新推荐文章于 2024-01-12 09:14:58 发布
阅读量198 收藏
点赞数
文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45743985/article/details/120825228
版权

缓存

  • 本地缓存：和微服务同一个进程。缺点：分布式时

  • 分布式缓存：缓存中间件

1. 本地缓存

category、brand、product

redis

redis学习笔记：【Redis】笔记（尚硅谷、黑马整合）_努力充实，远方可期-CSDN博客_尚硅谷redis笔记

安装docker-redis

product导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置redis主机地址

spring:
  redis:
    host: 192.168.56.10
    port: 6379

自动注入了RedisTemplate

优化菜单获取业务getCatalogJson

ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
String catalogJson = ops.get("catalogJson");
if (catalogJson == null) {
    Map<String, List<Catalog2Vo>> categoriesDb = getCategoriesDb();
    String toJSONString = JSON.toJSONString(categoriesDb);
    ops.set("catalogJson",toJSONString);
    return categoriesDb;
}
Map<String, List<Catalog2Vo>> listMap = JSON.parseObject(catalogJson, new TypeReference<Map<String, List<Catalog2Vo>>>() {});
return listMap;

lettuce堆外内存溢出bug

当进行压力测试时后期后出现堆外内存溢出OutOfDirectMemoryError

产生原因：

1)、springboot2.0以后默认使用lettuce作为操作redis的客户端，它使用netty进行网络通信

2)、lettuce的bug导致netty堆外内存溢出。netty如果没有指定堆外内存，默认使用Xms的值，可以使用-Dio.netty.maxDirectMemory进行设置 mory去调大虚拟机堆外内存，治标不治本。

1)、升级lettuce客户端。但是没有解决的 2)、切换使用jedis

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

lettuce和jedis是操作redis的底层客户端，RedisTemplate是再次封装

3) 缓存失效

缓存穿透

缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。

解决：缓存空对象、布隆过滤器、mvc拦截器

缓存雪崩

缓存雪崩是指在我们设置缓存时key采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩。

解决方案：

  • 规避雪崩：缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。

  • 如果缓存数据库是分布式部署，将热点数据均匀分布在不同缓存数据库中。

  • 设置热点数据永远不过期。

  • 出现雪崩：降级 熔断

  • 事前：尽量保证整个 redis 集群的高可用性，发现机器宕机尽快补上。选择合适的内存淘汰策略。

  • 事中：本地ehcache缓存 + hystrix限流&降级，避免MySQL崩掉

  • 事后：利用 redis 持久化机制保存的数据尽快恢复缓存

缓存击穿

缓存雪崩和缓存击穿不同的是：

  • 缓存击穿 指 并发查同一条数据。缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力

  • 缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

解决方案：

  • 设置热点数据永远不过期。

  • 加互斥锁：业界比较常用的做法，是使用mutex。简单地来说，就是在缓存失效的时候（判断拿出来的值为空），不是立即去load db去数据库加载，而是先使用缓存工具的某些带成功操作返回值的操作（比如Redis的SETNX或者Memcache的ADD）去set一个mutex key，当操作返回成功时，再进行load db的操作并回设缓存；否则，就重试整个get缓存的方法。

4) 缓存击穿:加锁

不好的方法是synchronized(this)，肯定不能这么写 ，不具体写了

锁时序问题：之前的逻辑是查缓存没有，然后取竞争锁查数据库，这样就造成多次查数据库。

解决方法：竞争到锁后，再次确认缓存中没有，再去查数据库。

 

如何复制微服务：

右键点击服务，copy configuration

在program arguments: --server.port=10003

2. 分布式缓存

本地缓存问题：每个微服务都要有缓存服务、数据更新时只更新自己的缓存，造成缓存数据不一致

解决方案：分布式缓存，微服务共用 缓存中间件

分布式锁

分布式项目时，但本地锁只能锁住当前服务，需要分布式锁

redis分布式锁的原理：setnx，同一时刻只能设置成功一个

前提，锁的key是一定的，value可以变

没获取到锁阻塞或者sleep一会

  • 设置好了锁，玩意服务出现宕机，没有执行删除锁逻辑，这就造成了死锁

    • 解决：设置过期时间

  • 业务还没执行完锁就过期了，别人拿到锁，自己执行完去删了别人的

    • 解决：锁续期（redisson有看门狗），。删锁的时候明确是自己的锁。如uuid

  • 判断uuid对了，但是将要删除的时候锁过期了，别人设置了新值，那删除了别人的锁

  • 解决：删除锁必须保证原子性（保证判断和删锁是原子的）。使用redis+Lua脚本完成，脚本是原子的

if redis.call("get",KEYS[1]) == ARGV[1] 
then
    return redis.call("del",KEYS[1])
else
    return 0
end;
stringRedisTemplate.execute(
    new DefaultRedisScript<Long返回值类型>(script脚本支付非常, Long.class返回值类型), 
    Arrays.asList("lock"), // 键key的集合
    lockValue);

set 命令 -- Redis中国用户组（CRUG）

最终代码：

public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
    String uuid = UUID.randomUUID().toString();
    ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
    Boolean lock = ops.setIfAbsent("lock", uuid,500, TimeUnit.SECONDS);
    if (lock) {
        Map<String, List<Catalog2Vo>> categoriesDb = getCategoryMap();
        String lockValue = ops.get("lock");
        // get和delete原子操作
        String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then\n" +
            "    return redis.call(\"del\",KEYS[1])\n" +
            "else\n" +
            "    return 0\n" +
            "end";
        stringRedisTemplate.execute(
            new DefaultRedisScript<Long>(script, Long.class), // 脚本和返回类型
            Arrays.asList("lock"), // 参数
            lockValue); // 参数值，锁的值
        return categoriesDb;
    }else {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 睡眠0.1s后，重新调用 //自旋
        return getCatalogJsonDbWithRedisLock();
    }
}

上面的lua脚本写法每次用分布式锁时比较麻烦，我们可以采用redisson现有框架

Distributed locks with Redis – Redis

Redisson

https://github.com/redisson/redisson

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括(BitSet,Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。

本文我们仅关注分布式锁的实现，更多请参考官方文档

(1) 环境搭建

导入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.13.4</version>
</dependency>
这个用作连续，后面可以使用redisson-spring-boot-starter

开启配置https://github.com/redisson/redisson/wiki/2.-%E9%85%8D%E7%BD%AE%E6%96%B9%E6%B3%95

@Configuration
public class MyRedisConfig {

    @Value("${ipAddr}")
    private String ipAddr;

    // redission通过redissonClient对象使用 // 如果是多个redis集群，可以配置
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() {
        Config config = new Config();
        // 创建单例模式的配置
        config.useSingleServer().setAddress("redis://" + ipAddr + ":6379");
        return Redisson.create(config);
    }
}

(2) 可重入锁（Reentrant Lock）

分布式锁：github.com/redisson/redisson/wiki/8.-分布式锁和同步器

A调用B。AB都需要同一锁，此时可重入锁就可以重入，A就可以调用B。不可重入锁时，A调用B将死锁

// 参数为锁名字
RLock lock = redissonClient.getLock("CatalogJson-Lock");//该锁实现了JUC.locks.lock接口
lock.lock();//阻塞等待
// 解锁放到finally // 如果这里宕机：有看门狗，不用担心
lock.unlock();

基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

锁的续期：大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟（每到20s就会自动续借成30s，是1/3的关系），也可以通过修改Config.lockWatchdogTimeout来另行指定。

// 加锁以后10秒钟自动解锁，看门狗不续命
// 无需调用unlock方法手动解锁
lock.lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
   try {
     ...
   } finally {
       lock.unlock();
   }
}
// 如果传递了锁的超时时间，就执行脚本，进行占锁;
// 如果没传递锁时间，使用看门狗的时间，占锁。如果返回占锁成功future，调用future.onComplete();
// 没异常的话调用scheduleExpirationRenewal(threadId);
// 重新设置过期时间，定时任务;
// 看门狗的原理是定时任务：重新给锁设置过期时间，新的过期时间就是看门狗的默认时间;
// 锁时间/3是定时任务周期;

Redisson同时还为分布式锁提供了异步执行的相关方法：

RLock lock = redisson.getLock("anyLock");
lock.lockAsync();
lock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = lock.tryLockAsync(100, 10, TimeUnit.SECONDS);

RLock对象完全符合Java的Lock规范。也就是说只有拥有锁的进程才能解锁，其他进程解锁则会抛出IllegalMonitorStateException错误。但是如果遇到需要其他进程也能解锁的情况，请使用分布式信号量Semaphore 对象.

public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisson() {
    Map<String, List<Catalog2Vo>> categoryMap=null;
    RLock lock = redissonClient.getLock("CatalogJson-Lock");
    lock.lock();
    try {
        Thread.sleep(30000);
        categoryMap = getCategoryMap();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }finally {
        lock.unlock();
        return categoryMap;
    }
}

最佳实战：自己指定锁时间，时间长点即可

(3) 读写锁（ReadWriteLock）

基于Redis的Redisson分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口。

分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态。

RReadWriteLock rwlock = redisson.getReadWriteLock("anyRWLock");
// 最常见的使用方法
rwlock.readLock().lock();
// 或
rwlock.writeLock().lock();
// 10秒钟以后自动解锁
// 无需调用unlock方法手动解锁
rwlock.readLock().lock(10, TimeUnit.SECONDS);
// 或
rwlock.writeLock().lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
// 或
boolean res = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();

上锁时在redis的状态

HashWrite-Lock
key:mode  value:read
key:sasdsdffsdfsdf... value:1

(4) 信号量（Semaphore）

信号量为存储在redis中的一个数字，当这个数字大于0时，即可以调用acquire()方法增加数量，也可以调用release()方法减少数量，但是当调用release()之后小于0的话方法就会阻塞，直到数字大于0

基于Redis的Redisson的分布式信号量（Semaphore）Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

RSemaphore semaphore = redisson.getSemaphore("semaphore");
semaphore.acquire();
//或
semaphore.acquireAsync();
semaphore.acquire(23);
semaphore.tryAcquire();
//或
semaphore.tryAcquireAsync();
semaphore.tryAcquire(23, TimeUnit.SECONDS);
//或
semaphore.tryAcquireAsync(23, TimeUnit.SECONDS);
semaphore.release(10);
semaphore.release();
//或
semaphore.releaseAsync();
@GetMapping("/park")
@ResponseBody
public String park() {
    RSemaphore park = redissonClient.getSemaphore("park");
    try {
        park.acquire(2);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "停进2";
}

@GetMapping("/go")
@ResponseBody
public String go() {
    RSemaphore park = redissonClient.getSemaphore("park");
    park.release(2);
    return "开走2";
}

(5) 闭锁（CountDownLatch）

基于Redisson的Redisson分布式闭锁（CountDownLatch）Java对象RCountDownLatch采用了与java.util.concurrent.CountDownLatch相似的接口和用法。

以下代码只有offLatch()被调用5次后 setLatch()才能继续执行

RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.trySetCount(1);
latch.await();

// 在其他线程或其他JVM里
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.countDown();

缓存和数据库一致性

  • 双写模式：写数据库后，写缓存

    • 问题：并发时，2写进入，写完DB后都写缓存。有暂时的脏数据

  • 失效模式：写完数据库后，删缓存

    • 问题：还没存入数据库呢，线程2又读到旧的DB了

    • 解决：缓存设置过期时间，定期更新

    • 解决：写数据写时，加分布式的读写锁。

解决方案：

  • 如果是用户纬度数据（订单数据、用户数据），这种并发几率非常小，不用考虑这个问题，缓存数据加上过期时间，每隔一段时间触发读的主动更新即可

  • 如果是菜单，商品介绍等基础数据，也可以去使用canal订阅binlog的方式

  • 缓存数据+过期时间也足够解决大部分业务对于缓存的要求。

  • 通过加锁保证并发读写，写写的时候按顺序排好队。读读无所谓。所以适合使用读写锁。（业务不关心脏数据，允许临时脏数据可忽略）；

总结：

  • 我们能放入缓存的数据本就不应该是实时性、一致性要求超高的。所以缓存数据的时候加上过期时间，保证每天拿到当前最新数据即可。

  • 我们不应该过度设计，增加系统的复杂性

  • 遇到实时性、一致性要求高的数据，就应该查数据库，即使慢点。

     

SpringCache

随便找篇cache文章阅读：SpringBoot-Cache-入门与基本使用_ervy的博客-CSDN博客_springboot的cache

.main.
关注
6、Redis Lettuce实战（含Spring Boot）
java爱分享
12-07 1130
在【Redis Jedis实战（含Spring Boot）】基础上做如下修改： 1、子pom.xml 去掉 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> 和 <exclusions...
Windows 下 Redis 安装与配置 教程
热门推荐
小青龍 的博客
06-14 16万+
Windows下Redis安装与配置教程，Windows下安装Redis的几种方式，msi安装包安装，zip安装包安装。使用SC命令，手动创建Redis服务及注册表服务项，实现Redis服务后台运行及服务自启动。Redis服务配置查看及修改，Redis服务各配置项简要说明。
spring Boot 1.x 升级 2.x
Marlene_me的博客
07-22 561
1、boot版本升级 升级前版本 <spring-boot.version>1.5.9.RELEASE</spring-boot.version> 升级后版本 <spring-boot.version>2.0.9.RELEASE</spring-boot.version> 2、boot升级后对应jar升级 1、redis包升级 <dependency> <groupId>org.springframework.boo
【Redis】Redis高级客户端Lettuce详解
DreamSun的博客
03-04 2239
支持Redis的新增命令ZPOPMIN, ZPOPMAX, BZPOPMIN, BZPOPMAX。支持通过Brave模块跟踪Redis命令执行。支持Redis Streams。支持异步的主从连接。支持异步连接池。新增命令最多执行一次模式（禁止自动重连）。全局命令超时设置（对异步和反应式命令也有效）。…等等注意一点：Redis的版本至少需要2.6，当然越高越好，API的兼容性比较强大。
在SpringBoot中集成Redis之Lettuce
wsdhla的专栏
06-29 496
在SpringBoot中集成Redis之Lettuce
redis Lettuce客户端
qq_37436172的博客
09-17 1138
与Jedis相比，Lettuce则完全克服了其线程不安全的缺点：Lettuce是一个可伸缩的线程安全的Redis客户端，支持同步、异步和响应式模式。 多个线程可以共享一个连接实例，而不必担心多线程并发问题。 它基于优秀Netty NIO框架构建，支持Redis的高级功能，如Sentinel，集群，流水线，自动重新连接和Redis数据模型。 Jedis在实现上是直接连接的redis server，如果在多线程环境下是非线程安全的，这个时候只有使用jedis pool连接池，为每个Jedis实例增加物理连接。
若依前后端分离版去redis版/无redis版本
11-07
基于前后端分离的应用，无论是否使用Redis，都需要考虑如何进行数据的存储和缓存。下面我将分别介绍基于Redis和无Redis的两种版本的特点。 基于Redis的版本 特点 缓存处理：Redis作为内存数据库可以用来缓存频繁访问...
redis-windows-7.0.11
05-05
Redis是一种开源的内存数据结构存储系统，它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等。Redis可以用作数据库、缓存和消息中间件。Redis在性能、可扩展性和灵活性方面表现出色，因此被广泛应用于Web...
redis-windows-7.2.3.zip
11-09
Redis，全称Remote Dictionary Server，是一款开源的、高性能的键值存储系统，广泛应用于缓存、消息队列、数据持久化等多个场景。它以其高效的数据处理能力，丰富的数据结构以及简单易用的API赢得了广大开发者青睐。...
redis-windows-7.2.1.zip
09-13
Redis，全称Remote Dictionary Server，是一款开源的、高性能的键值对存储系统，常用于数据缓存、消息队列和数据库等场景。在Windows环境下安装和使用Redis，可以通过下载对应的二进制压缩包来实现，比如"redis-...
SpringBoot2.x整合Redis6客户端
菜鸟联盟
08-05 748
一java语言客户端 Jedis 是直连模式，在多个线程间共享一个 Jedis 实例时是线程不安全的,需要使用连接池 其API提供了比较全面的Redis命令的支持，相比于其他Redis 封装框架更加原生 Jedis中的方法调用是比较底层的暴露的Redis的API，Java方法基本和Redis的API保持着一致 使用阻塞的I/O，方法调用同步，程序流需要等到socket处理完I/O才能执行，不支持异步操作 lettuce 高级Redis客户端，用于线程安全同步，异步响应 基于Net.
springboot 开发使用redis之 版本兼容性
最新发布
Java开源程序猿
01-12 2160
在Spring Boot应用中使用Redis时，确保你的Spring Boot版本和Spring Data Redis版本与Redis服务器的版本兼容是很重要的。查看Spring Data Redis的官方文档，了解与所使用的Spring Boot版本兼容的Spring Data Redis版本。然后，查看官方文档，了解该版本的Lettuce或Jedis与所使用的Redis服务器版本的兼容性。不同的Redis版本可能引入新的功能或更改协议，因此确保你的应用程序能够正确处理与Redis服务器版本相关的变化。
Spring Boot 2.5 实战 Redis 分布式 缓存 6.0
天空鸟的博客
11-04 1825
跟之前差不多，get by ID ， add user for 循环，构造 100 个用户，插入 list，后面。之前差不多，get by ID ， add user for 循环，构造 100 个用户，插入 list，后面。了抽象，本质上 Java 连 Redis 有基础 Redis 的驱动，使用基础的网络链接和 Redis 服。重要的 Java 驱动、工具驱动库，有 Redis 的链接池，使用的是比较有名的 Java 社群。Java 链接远程 Redis，Redis 服务器端要允许远程。
Spring Boot 2.3.0 新特性Redis 拓扑动态感应
冷冷的博客
06-11 2863
本文为原创文章。欢迎任何形式的转载，但请务必注明出处 冷冷https://lltx.github.io。 Spring Boot 2.3 新特性优雅停机详解 Spring Boot 2.3 新特性分层 JAR 本篇是 spring boot v2.3 系列第三篇，来分享一下 v2.3 关于 spring data redis 的故障转移优化。 背景 关于 Redis 在生产中我们一般情况下都会选择 redis cluster 高可用架构部署，既能保证数据分片并且实现节点的故障自动转移。 基本部署拓扑如.
lettuce连接池真有必要吗？
oppor9的博客
11-22 4311
在执行一些简单指令的情况下，lettuce不配置连接池，使用单连接是最佳方案。连接池配置太小，性能会急剧下降，连接池配置太大，性能和单连接情况下大致相当，但会造成资源浪费。
Spring Boot Starter Data Redis使用Lettuce客户端报错：NOAUTH Authentication required
Howinfun的博客
04-05 8840
Spring Boot Starter Data Redis使用Lettuce客户端报错：NOAUTH Authentication required
Redis高级客户端Lettuce详解
weixin_30567225的博客
09-28 2271
前提 Lettuce是一个Redis的Java驱动包，初识她的时候是使用RedisTemplate的时候遇到点问题Debug到底层的一些源码，发现spring-data-redis的驱动包在某个版本之后替换为Lettuce。Lettuce翻译为生菜，没错，就是吃的那种生菜，所以它的Logo长这样： 既然能被Spring生态所认可，Lettuce想必有过人之处，于是笔者花时间阅读她的官方...
Redis 高级 Java 客户端 Lettuce 的用法及踩坑经验
qq_43683014的博客
11-15 5347
Redis 高级 Java 客户端 Lettuce 的用法及踩坑经验
一起来学SpringBoot | 第九篇：整合Lettuce Redis
LuisChen的博客
06-07 3万+
SpringBoot是为了简化Spring应用的创建、运行、调试、部署等一系列问题而诞生的产物，自动装配的特性让我们可以更好的关注业务本身而不是外部的XML配置，我们只需遵循规范，引入相关的依赖就可以轻易的搭建出一个 WEB 工程 Spring Boot除了支持常见的ORM框架外，更是对常用的中间件提供了非常好封装，随着Spring Boot2.x的到来，支持的组件越来越丰富，也越来越成...
Redis 3.0.0 安装教程
"Redis 是一个高性能的键值存储系统，常用于数据库、缓存和消息中间件等场景。本文档将指导你完成Redis的安装步骤。" 在安装Redis之前，你需要确保你的系统已经安装了GCC编译器，因为Redis源码包需要通过GCC来编译...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值