Linux操作系统中Redis

news2024/9/30 19:54:30

1、什么是Redis

Redis(Remote Dictionary Server ),即远程字典服务,是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。

可以理解成一个大容量的map。

2、Redis的作用

可以做为数据库存储数据,也可以用来做缓存、计数器、分布式锁等。实际工作中很少用它做数据库。

3、Redis常用的五种基本类型【必问】

  • string:字符串数据类型

  • hash:类似于对象,map的形式

  • list:表示一种线性数据结构,队列或栈

  • set:无序不可重复集合

  • zset:有序不可重复集合

另外还有三种数据类型,都不是很常用。Geospatial、Bitmap、Hyperloglog

redis可以操作位(bit),但是工作中几乎不用。

4、安装redis

基于docker的安装

4.1、查询镜像文件【省略】

#可以不操作:
docker search redis

4.2、拉取镜像文件

docker pull redis:6.2.6

4.3、启动redis并设置密码

docker run -d --name redis-6379 -p 6379:6379 redis:6.2.6 --requirepass 123456

requirepass:设置密码

【工作时:】启动redis注意事项:

  • 密码一定要设置,复杂一点

  • 端口映射,redis一定不能用默认端口,用默认端口一定会被攻击

4.3.1、修改redis密码【可以不修改】

# 1/进入redis容器
docker exec -it redis-6379 /bin/bash
# 2/找到redis-cli可执行文件
cd /usr/local/bin
# 3/执行redis-cli
redis-cli
# 4/查看密码
config get requirepass
# 5/授权
auth 密码
# 6/修改密码
config set requirepass 新密码

第一步骤:进入redis容器

第二步骤:找到redis-cli可执行文件

第三步骤:执行redis-cli

第四步骤:查看密码(显示没有授权)

第五步骤:授权

第六步骤:修改密码(最好还是使用123456,后面整合的时候,容易忘记。)

第七步骤:退出容器

4.3.2、删除密码【坚决不推荐】

config set requirepass ''

5、SpringBoot整合

1、添加maven依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.jsoft</groupId>
    <artifactId>demo-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
​
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.13</version>
    </parent>
​
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.6.13</spring-boot.version>
        <jwt.version>0.7.0</jwt.version>
        <fastjson.version>1.2.60</fastjson.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--json-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
    </dependencies>
​
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <classifier>exec</classifier>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2、添加redis配置

spring:  
  redis:
    host: 192.168.2.102
    port: 6379
    password: 123456

3、添加redisconfig

package com.jr.config;
​
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
​
@Configuration
public class RedisConfig {
​
    /**
     * 配置 RedisTemplate<String, Object>
     * 设置了键和值的序列化方式,键用字符串序列化,值用JSON序列化
     *
     * @return RedisTemplate
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer();
        StringRedisSerializer keySerialize = new StringRedisSerializer();
        RedisTemplate<String, Object> result = new RedisTemplate<>();
        result.setConnectionFactory(redisConnectionFactory);
        result.setKeySerializer(keySerialize);
        result.setValueSerializer(valueSerializer);
        result.setHashKeySerializer(keySerialize);
        result.setHashValueSerializer(valueSerializer);
        return result;
    }
​
}

4、添加SpringBoot启动类:

@SpringBootApplication
public class SpringBootMain {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootMain.class);
    }+
}

5、常用方法介绍【必问,记住3-5方法】

1.redisTemplate

redisTemplate.hasKey(key);              //判断是否有key所对应的值,有则返回true,没有则返回false
redisTemplate.opsForValue().get(key);   //有则取出key值所对应的值
redisTemplate.delete(key);              //删除单个key值
redisTemplate.delete(keys);             //其中keys:Collection<K> keys
redisTemplate.dump(key);                //将当前传入的key值序列化为byte[]类型
redisTemplate.expire(key, timeout, unit);   //设置过期时间
redisTemplate.expireAt(key, date);      //设置过期时间
redisTemplate.keys(pattern);            //查找匹配的key值,返回一个Set集合类型
redisTemplate.rename(oldKey, newKey);   //返回传入key所存储的值的类型
redisTemplate.renameIfAbsent(oldKey, newKey);   //如果旧值存在时,将旧值改为新值
redisTemplate.randomKey();              //从redis中随机取出一个key
redisTemplate.getExpire(key);           //返回当前key所对应的剩余过期时间
redisTemplate.getExpire(key, unit);     //返回剩余过期时间并且指定时间单位
redisTemplate.persist(key);             //将key持久化保存
redisTemplate.move(key, dbIndex);       //将当前数据库的key移动到指定redis中数据库当中

【测试代码】

@Slf4j
@SpringBootTest(classes = DemoHelloworldApplication.class)
@SuppressWarnings("all")
public class RedisTest {
​
    private static final String KEY = "test:commonKey";
​
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
​
    @Test
    public void testCommon() {
        testCommon(KEY);
    }
​
    public void testCommon(String key) {
        boolean hasKey = redisTemplate.hasKey(key); //hasKey(key);
        log.info("hasKey {}", hasKey);
        boolean delete = redisTemplate.delete(key); //delete(key);
        log.info("delete {}", delete);
    }
​
    public void delete(String key) {
        boolean delete = redisTemplate.delete(key);
    }
}  

2.ValueOperations=>String

ValueOperations opsForValue = redisTemplate.opsForValue();
​
opsForValue.set(key, value);    //设置当前的key以及value值
opsForValue.set(key, value, offset);//用 value 参数覆写给定 key 所储存的字符串值,从偏移量 offset 开始
opsForValue.set(key, value, timeout, unit);  //设置当前的key以及value值并且设置过期时间
opsForValue.setBit(key, offset, value); //将二进制第offset位值变为value
opsForValue.setIfAbsent(key, value);//重新设置key对应的值,如果存在返回false,否则返回true
opsForValue.get(key, start, end);   //返回key中字符串的子字符
opsForValue.getAndSet(key, value);  //将旧的key设置为value,并且返回旧的key
opsForValue.multiGet(keys);         //批量获取值
opsForValue.size(key);              //获取字符串的长度
opsForValue.append(key, value); //在原有的值基础上新增字符串到末尾
opsForValue.increment(key,double increment);//以增量的方式将double值存储在变量中
opsForValue.increment(key,long  increment); //通过increment(K key, long delta)方法以增量方式存储long值(正值则自增,负值则自减)
 
Map valueMap = new HashMap();  
valueMap.put("valueMap1","map1");  
valueMap.put("valueMap2","map2");  
valueMap.put("valueMap3","map3");  
opsForValue.multiSetIfAbsent(valueMap);     //如果对应的map集合名称不存在,则添加否则不做修改
opsForValue.multiSet(valueMap);             //设置map集合到redis
​

【测试代码】

@Slf4j
@SpringBootTest(classes = DemoHelloworldApplication.class)
@SuppressWarnings("all")
public class RedisTest {
​
    private static final String KEY = "test:commonKey";
​
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
​
    /**
     * - string:字符串数据类型
     */
    @Test
    public void testString() {
        String key = "test:string";
        String key2 = "test:increment";
        String key3 = "test:object";
        delete(key);
        delete(key2);
        delete(key3);
        redisTemplate.opsForValue().set(key, "zhangsan");  // set(key, "zhangsan");
        Object value = redisTemplate.opsForValue().get(key); // get(key);
        log.info("value {}", value);
        redisTemplate.opsForValue().set(key, "lisi");
        value = redisTemplate.opsForValue().get(key);
        log.info("value {}", value);
        testCommon(key);
        boolean hasKey = redisTemplate.hasKey(key);
        log.info("hasKey {}", hasKey);
        
        
        redisTemplate.opsForValue().increment(key2, 10);// increment(key2, 10);计数器
        value = redisTemplate.opsForValue().get(key2);
        log.info("value {}", value);
        redisTemplate.opsForValue().increment(key2); // increment(key2); 涨1;increment(key2,10);涨10
        value = redisTemplate.opsForValue().get(key2);
        log.info("value {}", value);
        
        
        User user = new User();
        user.setName("zhangsan");
        user.setPassword("123456");
        redisTemplate.opsForValue().set(key3, user);
        value = redisTemplate.opsForValue().get(key3);
        log.info("value {}", value);
    }
}    

3.HashOperations=>Hash

HashOperations opsForHash = redisTemplate.opsForHash();
​
opsForHash.get(key, field); //获取变量中的指定map键是否有值,如果存在该map键则获取值,没有则返回null
opsForHash.entries(key);    //获取变量中的键值对
opsForHash.put(key, hashKey, value);    //新增hashMap值
opsForHash.putAll(key, maps);   //以map集合的形式添加键值对
opsForHash.putIfAbsent(key, hashKey, value);    //仅当hashKey不存在时才设置
opsForHash.delete(key, fields); //删除一个或者多个hash表字段
opsForHash.hasKey(key, field);  //查看hash表中指定字段是否存在
opsForHash.increment(key, field, long increment);   //给哈希表key中的指定字段的整数值加上增量increment
opsForHash.increment(key, field, double increment); //给哈希表key中的指定字段的整数值加上增量increment
opsForHash.keys(key);               //获取所有hash表中字段
opsForHash.values(key);             //获取hash表中存在的所有的值
opsForHash.scan(key, options);      //匹配获取键值对,ScanOptions.NONE为获取全部键对

【测试代码】

@Slf4j
@SpringBootTest(classes = DemoHelloworldApplication.class)
@SuppressWarnings("all")
public class RedisTest {
​
    private static final String KEY = "test:commonKey";
​
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
​
    /**
     * - hash:类似于对象,map的形式
     */
    @Test
    public void testHash() {
        String key = "test:hash";
        redisTemplate.opsForHash().put(key, "name", "zhangsan");
        redisTemplate.opsForHash().put(key, "age", 12);
        Object name = redisTemplate.opsForHash().get(key, "name");
        Object age = redisTemplate.opsForHash().get(key, "age");
        log.info("name {}", name);
        log.info("age {}", age);
    }
}    

4.ListOperations=>List

ListOperations opsForList = redisTemplate.opsForList();
​
opsForList.index(key, index);   //通过索引获取列表中的元素
opsForList.range(key, start, end);  //获取列表指定范围内的元素(start开始位置, 0是开始位置,end 结束位置, -1返回所有)
opsForList.leftPush(key, value);    //存储在list的头部,即添加一个就把它放在最前面的索引处
opsForList.leftPush(key, pivot, value);     //如果pivot处值存在则在pivot前面添加
opsForList.leftPushAll(key, value);     //把多个值存入List中(value可以是多个值,也可以是一个Collection value)
opsForList.leftPushIfPresent(key, value);   //List存在的时候再加入
opsForList.rightPush(key, value);   //按照先进先出的顺序来添加(value可以是多个值,或者是Collection var2)
opsForList.rightPushAll(key, value);    //在pivot元素的右边添加值
opsForList.set(key, index, value);      //设置指定索引处元素的值
opsForList.trim(key, start, end);       //将List列表进行剪裁
opsForList.size(key);   //获取当前key的List列表长度
 
//移除并获取列表中第一个元素(如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止)
opsForList.leftPop(key);                
opsForList.leftPop(key, timeout, unit); 
 
//移除并获取列表最后一个元素
opsForList.rightPop(key);
opsForList.rightPop(key, timeout, unit);    
 
//从一个队列的右边弹出一个元素并将这个元素放入另一个指定队列的最左边
opsForList.rightPopAndLeftPush(sourceKey, destinationKey);  
opsForList.rightPopAndLeftPush(sourceKey, destinationKey, timeout, unit);
 
//删除集合中值等于value的元素(index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素; index<0, 从尾部开始删除第一个值等于value的元素)
opsForList.remove(key, index, value);

【测试代码】

@Slf4j
@SpringBootTest(classes = DemoHelloworldApplication.class)
@SuppressWarnings("all")
public class RedisTest {
​
    private static final String KEY = "test:commonKey";
​
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
​
    /**
     * - list:表示一种线性数据结构,队列或栈
     */
    @Test
    public void testList() {
        String key = "test:list";
        
        log.info("----------------------- {}", "模拟队列");
        /*模拟队列*/
        for (int i = 0; i < 5; i++) {
            redisTemplate.opsForList().leftPush(key, i);
        }
        long listSize = redisTemplate.opsForList().size(key);
        log.info("listSize {}", listSize);
        for (int i = 0; i < listSize; i++) {
            log.info("test:list {}", redisTemplate.opsForList().rightPop(key));
        }
        listSize = redisTemplate.opsForList().size(key);
        log.info("listSize {}", listSize);
        
        
        log.info("----------------------- {}", "模拟栈");
        /*模拟栈*/
        for (int i = 0; i < 5; i++) {
            redisTemplate.opsForList().leftPush(key, i);
        }
        listSize = redisTemplate.opsForList().size(key);
        log.info("listSize {}", listSize);
        for (int i = 0; i < listSize; i++) {
            log.info("test:list {}", redisTemplate.opsForList().leftPop(key));
        }
        listSize = redisTemplate.opsForList().size(key);
        log.info("listSize {}", listSize);
        
    }
}   

5.SetOperations=>Set

SetOperations opsForSet = redisTemplate.opsForSet();
​
opsForSet.add(key, values);         //添加元素
opsForSet.remove(key, values);      //移除元素(单个值、多个值)
opsForSet.pop(key);                 //删除并且返回一个随机的元素
opsForSet.size(key);                //获取集合的大小
opsForSet.isMember(key, value);     //判断集合是否包含value
opsForSet.intersect(key, otherKey); //获取两个集合的交集(key对应的无序集合与otherKey对应的无序集合求交集)
opsForSet.intersect(key, otherKeys);//获取多个集合的交集(Collection var2)
opsForSet.intersectAndStore(key, otherKey, destKey);    //key集合与otherKey集合的交集存储到destKey集合中(其中otherKey可以为单个值或者集合)
opsForSet.intersectAndStore(key, otherKeys, destKey);   //key集合与多个集合的交集存储到destKey无序集合中
opsForSet.union(key, otherKeys);    //获取两个或者多个集合的并集(otherKeys可以为单个值或者是集合)
opsForSet.unionAndStore(key, otherKey, destKey);    //key集合与otherKey集合的并集存储到destKey中(otherKeys可以为单个值或者是集合)
opsForSet.difference(key, otherKeys);   //获取两个或者多个集合的差集(otherKeys可以为单个值或者是集合)
opsForSet.differenceAndStore(key, otherKey, destKey);   //差集存储到destKey中(otherKeys可以为单个值或者集合)
opsForSet.randomMember(key);    //随机获取集合中的一个元素
opsForSet.members(key);         //获取集合中的所有元素
opsForSet.randomMembers(key, count);    //随机获取集合中count个元素
opsForSet.distinctRandomMembers(key, count);    //获取多个key无序集合中的元素(去重),count表示个数
opsForSet.scan(key, options);   //遍历set类似于Interator(ScanOptions.NONE为显示所有的)

【测试代码】

@Slf4j
@SpringBootTest(classes = DemoHelloworldApplication.class)
@SuppressWarnings("all")
public class RedisTest {
​
    private static final String KEY = "test:commonKey";
​
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
​
    /**
     * - set:无序不可重复集合
     */
    @Test
    public void testSet() {
        String key = "test:set";
        redisTemplate.opsForSet().add(key, "zhangsan", "lisi", "wangwu", 12, 22, 32, "wangwu", 12, "12");
        long listSize = redisTemplate.opsForSet().size(key);
        log.info("listSize {}", listSize);
        for (int i = 0; i < listSize; i++) {
            log.info("test:set {}", redisTemplate.opsForSet().pop(key));
        }
        listSize = redisTemplate.opsForSet().size(key);
        log.info("listSize {}", listSize);
    }
}   

6.ZSetOperations=>zSet

ZSetOperations提供了一系列方法对有序集合进行操作
ZSetOperations opsForZSet = redisTemplate.opsForZSet();
​
opsForZSet.add(key, value, score);              //添加元素(有序集合是按照元素的score值由小到大进行排列)
opsForZSet.remove(key, values);                 //删除对应的value,value可以为多个值
opsForZSet.incrementScore(key, value, delta);   //增加元素的score值,并返回增加后的值
opsForZSet.rank(key, value);                    //返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
opsForZSet.reverseRank(key, value);             //返回元素在集合的排名,按元素的score值由大到小排列
opsForZSet.reverseRangeWithScores(key, start,end);  //获取集合中给定区间的元素(start 开始位置,end 结束位置, -1查询所有)
opsForZSet.reverseRangeByScore(key, min, max);  //按照Score值查询集合中的元素,结果从小到大排序
opsForZSet.reverseRangeByScoreWithScores(key, min, max);    //返回值为:Set<ZSetOperations.TypedTuple<V>>
opsForZSet.count(key, min, max);                //根据score值获取集合元素数量
opsForZSet.size(key);                           //获取集合的大小
opsForZSet.zCard(key);                          //获取集合的大小
opsForZSet.score(key, value);                   //获取集合中key、value元素对应的score值
opsForZSet.removeRange(key, start, end);        //移除指定索引位置处的成员
opsForZSet.removeRangeByScore(key, min, max);   //移除指定score范围的集合成员
opsForZSet.unionAndStore(key, otherKey, destKey);//获取key和otherKey的并集并存储在destKey中(其中otherKeys可以为单个字符串或者字符串集合)
opsForZSet.intersectAndStore(key, otherKey, destKey);   //获取key和otherKey的交集并存储在destKey中(其中otherKeys可以为单个字符串或者字符串集合)

【测试代码】

@Slf4j
@SpringBootTest(classes = DemoHelloworldApplication.class)
@SuppressWarnings("all")
public class RedisTest {
​
    private static final String KEY = "test:commonKey";
​
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
​
    /**
     * - zset:有序不可重复集合
     */
    @Test
    public void testZset() {
        String key = "test:zset";
        redisTemplate.opsForZSet().add(key, "zhangsan", 12);
        redisTemplate.opsForZSet().add(key, "lisi", 22);
        redisTemplate.opsForZSet().add(key, "wangwu", 32);
        redisTemplate.opsForZSet().add(key, "wangwu1", 121);
        redisTemplate.opsForZSet().add(key, "wangwu2", 122);
        redisTemplate.opsForZSet().add(key, "wangwu3", 123);
        redisTemplate.opsForZSet().add(key, "wangwu4", 124);
        redisTemplate.opsForZSet().add(key, "wangwu5", 125);
        redisTemplate.opsForZSet().add(key, "wangwu6", 126);
        Long zCard = redisTemplate.opsForZSet().zCard(key);//
        long listSize = redisTemplate.opsForZSet().size(key);
        log.info("zCard {}", zCard);
        log.info("listSize {}", listSize);
//        for (int i = 0; i < listSize; i++) {
//            log.info("test:set {}", redisTemplate.opsForZSet().popMax(key));
//        }
        listSize = redisTemplate.opsForZSet().size(key);
        log.info("listSize {}", listSize);
        log.info("----------------------- {}", "华丽的分割线");
        Set<Object> range = redisTemplate.opsForZSet().range(key, 1, 3);
        for (Object o : range) {
            log.info("range {}", o);
        }
        listSize = redisTemplate.opsForZSet().size(key);
        log.info("listSize {}", listSize);
    }
}

6、面试题:

1、缓存穿透
一、概念

  缓存穿透:缓存和数据库中都没有的数据,可用户还是源源不断的发起请求,导致每次请求都会到数据库,从而压垮数据库。

  如下图红色的流程:

  比如客户查询一个根本不存在的东西,首先从Redis中查不到,然后会去数据库中查询,数据库中也查询不到,那么就不会将数据放入到缓存中,后面如果还有类似源源不断的请求,最后都会压到数据库来处理,从而给数据库造成巨大的压力。

二、解决办法

①、业务层校验

  用户发过来的请求,根据请求参数进行校验,对于明显错误的参数,直接拦截返回。

  比如,请求参数为主键自增id,那么对于请求小于0的id参数,明显不符合,可以直接返回错误请求。

②、不存在数据设置短过期时间

对于某个查询为空的数据,可以将这个空结果进行Redis缓存,但是设置很短的过期时间,比如30s,可以根据实际业务设定。注意一定不要影响正常业务。

③、布隆过滤器

  关于布隆过滤器,后面会详细介绍。布隆过滤器是一种数据结构,利用极小的内存,可以判断大量的数据“一定不存在或者可能存在”。

  对于缓存击穿,我们可以将查询的数据条件都哈希到一个足够大的布隆过滤器中,用户发送的请求会先被布隆过滤器拦截,一定不存在的数据就直接拦截返回了,从而避免下一步对数据库的压力。

2、缓存击穿
一、概念

  缓存击穿:Redis中一个热点key在失效的同时,大量的请求过来,从而会全部到达数据库,压垮数据库。

  这里要注意的是这是某一个热点key过期失效,和后面介绍缓存雪崩是有区别的。比如淘宝双十一,对于某个特价热门的商品信息,缓存在Redis中,刚好0点,这个商品信息在Redis中过期查不到了,这时候大量的用户又同时正好访问这个商品,就会造成大量的请求同时到达数据库。

二、解决办法

①、设置热点数据永不过期

  对于某个需要频繁获取的信息,缓存在Redis中,并设置其永不过期。当然这种方式比较粗暴,对于某些业务场景是不适合的。

②、定时更新

  比如这个热点数据的过期时间是1h,那么每到59minutes时,通过定时任务去更新这个热点key,并重新设置其过期时间。

  ③、互斥锁

这是解决缓存穿透比较常用的方法。

  互斥锁简单来说就是在Redis中根据key获得的value值为空时,先锁上,然后从数据库加载,加载完毕,释放锁。若其他线程也在请求该key时,发现获取锁失败,则睡眠一段时间(比如100ms)后重试。

3、缓存雪崩
一、概念

  缓存雪崩:Redis中缓存的数据大面积同时失效,或者Redis宕机,从而会导致大量请求直接到数据库,压垮数据库。

  对于一个业务系统,如果Redis宕机或大面积的key同时过期,会导致大量请求同时打到数据库,这是灾难性的问题。

二、解决办法

①、设置有效期均匀分布

  避免缓存设置相近的有效期,我们可以在设置有效期时增加随机值;

  或者统一规划有效期,使得过期时间均匀分布。

②、数据预热

  对于即将来临的大量请求,我们可以提前走一遍系统,将数据提前缓存在Redis中,并设置不同的过期时间。

③、保证Redis服务高可用

  前面我们介绍过Redis的哨兵模式和集群模式,为防止Redis集群单节点故障,可以通过这两种模式实现高可用。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2180564.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

《向量数据库指南》——Milvus 和 Fivetran 如何为 AI 构建基础

哈哈,说起 Milvus 和 Fivetran 如何为 AI 构建基础,这可真是个有意思的话题!来,让我这个向量数据库领域的“老司机”给你详细讲解一番,保证让你听得津津有味,还能学到不少干货! Milvus 和 Fivetran:AI 搜索解决方案的黄金搭档 在当今这个数据爆炸的时代,AI 已经成为…

《软件工程概论》作业一:新冠疫情下软件产品设计(小区电梯实体按钮的软件替代方案)

课程说明&#xff1a;《软件工程概论》为浙江科技学院2018级软件工程专业在大二下学期开设的必修课。课程使用《软件工程导论&#xff08;第6版&#xff09;》&#xff08;张海藩等编著&#xff0c;清华大学出版社&#xff09;作为教材。以《软件设计文档国家标准GBT8567-2006》…

net core mvc 数据绑定 《2》 bind fromquery,FromRoute,fromform等,自定义模型绑定器

mvc core 模型绑定 控制绑定名称 》》》Bind 属性可以用来指定 模型应该 绑定的前缀 public class MyController : Controller {[HttpPost]public ActionResult Create([Bind(Prefix "MyModel")] Ilist<MyModel> model){// 模型绑定将尝试从请求的表单数据中…

Vue2实现主内容滚动到指定位置时,侧边导航栏也跟随选中变化

需求背景&#xff1a; PC端项目需要实现一个有侧边导航栏&#xff0c;可点击跳转至对应内容区域&#xff0c;类似锚点导航&#xff0c; 同时主内容区域上下滚动时&#xff0c;可实现左侧导航栏选中样式能实时跟随变动的效果。 了解了一下&#xff0c;Element Plus 组件库 和 …

从源码中学习动态代理模式

动态代理模式 动态代理是 Java 反射&#xff08;Reflection&#xff09;API 提供的一种强大机制&#xff0c;它允许在运行时创建对象的代理实例&#xff0c;而不需要在编译时静态地创建。 Java 提供了两种主要的方式来实现动态代理&#xff1a; 基于接口的动态代理&#xff1a…

2024/9/29周报

文章目录 摘要Abstract污水处理工艺流程整体介绍粗格栅细格栅曝气沉砂池提升泵房峰谷平策略 初沉池&#xff08;一级处理&#xff09;工作原理运行管理 氧化沟生化池&#xff08;二级处理&#xff09;二沉池工作原理运行参数 高效沉淀池功能与特点工作原理 深度处理&#xff08…

[BUUCTF从零单排] Web方向 03.Web入门篇之sql注入-1(手工注入详解)

这是作者新开的一个专栏《BUUCTF从零单排》&#xff0c;旨在从零学习CTF知识&#xff0c;方便更多初学者了解各种类型的安全题目&#xff0c;后续分享一定程度会对不同类型的题目进行总结&#xff0c;并结合CTF书籍和真实案例实践&#xff0c;希望对您有所帮助。当然&#xff0…

html+css+js实现dialog对话框

实现效果 HTML部分 <span class"text">点击打开 Dialog</span><!-- 警告框 --><div class"alert"><div class"header"><i>X</i> </div><div class"content">确认关闭</di…

Python 实现 YouTube 视频自动上传

文章目录 前言申请 Google API 秘钥启用 API创建项目凭证配置 API下载生成的凭据文件 youtube-upload 工具使用安装配置秘钥使用 其它问题程序尚未完成 Google 验证流程 个人简介 前言 youtube-upload 库 Python 中一个用于实现 YouTube 视频自动上传的实用工具。以下是关于如…

【 微信机器人+ AI 搭建】

摘要&#xff1a; 各种大模型已经出来好久了&#xff0c;各类app也已经玩腻了&#xff0c;接下来&#xff0c;就在考虑&#xff0c;怎么让大模型&#xff0c;利益最大化。 本人没有显著的家世&#xff0c;没有富婆包养&#xff0c;只能自己抽点时间&#xff0c;研究下技术&…

Java使用BeanUtils.copyProperties实现对象的拷贝

1、BeanUtils.copyProperties() 方法的使用 BeanUtils.copyProperties 方法是 Java 中 Spring 框架提供的一个非常实用的工具方法&#xff0c;它用于将一个 JavaBean 对象的属性值拷贝到另一个 JavaBean 对象中。这个方法主要用于简化对象之间的数据转换过程&#xff0c;尤其是…

数学-傅里叶级数的推导

目录&#xff1a; 1、矢量的正交分解 2、信号的正交分解 3、傅里叶级数形式★ 本篇摘录“信号与系统3-傅里叶变换与频域分析”的小部分内容。 1、矢量的正交分解 两矢量V1与V2正交&#xff0c;夹角为90&#xff0c;那么两正交矢量的内积为零&#xff0c;如下图所示。 图4.2…

Excel实现省-市-区/县级联

数据准备 准备省份-城市映射数据&#xff0c;如下&#xff1a; 新建sheet页&#xff0c;命名为&#xff1a;省-市数据源&#xff0c;然后准备数据&#xff0c;如下所示&#xff1a; 准备城市-区|县映射数据&#xff0c;如下&#xff1a; 新建sheet页&#xff0c;命名为&#x…

Open WebUI部署自己的大模型

相关代码地址见文末 1. 概述 Text Generation WebUI 是一个基于网页的界面,提供使用不同语言模型(如Transformers、Llama、ExLlamav2等)进行文本生成的功能。该软件支持以下主要功能: 模型加载:支持从多种框架加载单个或多个LoRA。LoRA微调:在支持的加载器上进行低秩适…

计算神经学笔记01

- **The term neuromorphic is generally used to describe analog, digital, mixed-mode analog/digital VLSI, and software systems that implement several models of neural systems.** - 神经形态一词通常用于描述模拟、数字、混合模式的模拟/数字超大规模集成电路&…

YOLO V8半自动标注工具设计

前提&#xff1a; 对于某些边界不明确的小目标&#xff0c;要是目标由比较多的话&#xff0c;标注起来就会非常麻烦。 如何利用已有训练模型&#xff0c;生成框&#xff0c;进行预标注。再通过调节预标注框的方式&#xff0c;提高标注的效率。 1 通过预先训练的模型生成yolo 格…

12.C++程序中的自定义函数

11.C程序中的常用函数-CSDN博客https://blog.csdn.net/fly_binbin/article/details/142643406上面说的是C程序中内置的一些函数&#xff0c;这些函数是由编译器提供的&#xff0c;可以方便大家的使用&#xff0c;但是很多时候&#xff0c;单纯的内置函数无法满足人们的需求&…

排序题目:重新排列后的最大子矩阵

文章目录 题目标题和出处难度题目描述要求示例数据范围 解法思路和算法代码复杂度分析 题目 标题和出处 标题&#xff1a;重新排列后的最大子矩阵 出处&#xff1a;1727. 重新排列后的最大子矩阵 难度 7 级 题目描述 要求 给定一个大小为 m n \texttt{m} \times \tex…

第三方供应商不提供API接口?教你四步破解集成难题

API开放需求 在企业数字化转型过程中&#xff0c;异构系统之间的连接是信息化阶段不可或缺的一环。通过应用API&#xff0c;企业能够实现不同系统、平台和应用之间的数据交换与功能调用&#xff0c;从而形成端到端的业务流程协同。然而&#xff0c;很多企业在集成第三方供应商…

web应用合规(一)双因子认证2FA解决方案

文章目录 背景知识什么是2FA认证因子分类知识因素持有因素 解决方案密码 OTP密码 TOTP方案对比 参考文档后记 最近做海外项目&#xff0c;对合规方面的要求比较高&#xff0c;写一篇流水账来记录下 登录时的双因子认证过程&#xff0c;于是开启了2FA&#xff08;2 factor au…