精华内容
下载资源
问答
  • 一、redis做缓存的优缺点 (1)优点:简单灵活、数据结构丰富、高速读写。 (2)缺点:持久化、要尽量避免或者设计机制保障。存储成本高,存储在内存中,从而要尽量避免使用redis进行大量数据存储。 二、示例 本文...

    一、redis做缓存的优缺点

    (1)优点:简单灵活、数据结构丰富、高速读写。

    (2)缺点:持久化、要尽量避免或者设计机制保障。存储成本高,存储在内存中,从而要尽量避免使用redis进行大量数据存储。

    二、示例

    本文使用Spring的RedisTemplate来操作Redis。采用SpringBoot对redis的自动配置。

    (1)配置redis的连接信息。

    spring.redis.database=0
    spring.redis.host=localhost
    spring.redis.port=6379
    spring.redis.password=
    spring.redis.pool.max-active=8
    spring.redis.pool.max-wait=-1
    spring.redis.pool.max-idle=8
    spring.redis.pool.min-idle=0
    spring.redis.timeout=0

    (2)Redis配置类添加RedisTemplate。

    package com.liutao.config;
    
    import com.liutao.utils.RedisObjectSerializer;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /**
     * redis配置类
     *
     * @author LIUTAO
     * @version 2017/5/16
     * @see
     */
    @Configuration
    public class RedisConfig {
        @Bean
        JedisConnectionFactory jedisConnectionFactory() {
            return new JedisConnectionFactory();
        }
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(factory);
            template.setKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(new RedisObjectSerializer());
            template.afterPropertiesSet();
            return template;
        }
    }
    

    (3)编写redis客户端。

    package com.liutao.utils;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * redis客户端工具类
     *
     * @author LIUTAO
     * @version 2017/5/15
     * @see
     */
    @Component
    public class RedisClient {
        private static Logger logger = LoggerFactory.getLogger(RedisClient.class);
        @Autowired
        private RedisTemplate redisTemplate;
    
        /**
         * 保存数据进入缓存
         *
         * @param key          键
         * @param value        值
         * @param cacheSeconds 缓存时间
         */
        public void putObject(final String key, final Object value, final int cacheSeconds) {
            redisTemplate.opsForValue().set(key, value, cacheSeconds, TimeUnit.SECONDS);
        }
    
        /**
         * get操作
         *
         * @param key 键
         * @return
         */
        public Object getObject(final String key) {
            return redisTemplate.opsForValue().get(key);
        }
    
    
        /**
         * 从缓存中删除对象
         *
         * @param key 键
         * @return
         */
        public int del(final String key) {
            try {
                redisTemplate.delete(key);
                return 1;
            } catch (Exception e) {
                return 0;
            }
    
        }
    
        /**
         * 判断缓存数据是否存在
         *
         * @param key
         * @return
         */
        public boolean exists(final String key) {
            return redisTemplate.hasKey(key);
        }
    }
    

    (4)编写测试Controller

    package com.liutao.controller;
    
    import com.liutao.entity.User;
    import com.wordnik.swagger.annotations.Api;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import com.liutao.utils.RedisClient;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 用户控制层
     *
     * @author LIUTAO
     * @version 2017/3/29
     * @see
     */
    @RestController
    @Api(value = "test")
    @RequestMapping("/liutao/v1")
    public class UserController {
    
        private Logger logger = LoggerFactory.getLogger(UserController.class);
    
        @Autowired
        private RedisClient redisClient;
        /**
         * 缓存测试
         *
         * @return
         * @author SHANHY
         * @create 2016年9月12日
         */
        @GetMapping("/redisTest")
        public String redisTest() {
            try {
                redisClient.putObject("test-key", "redis测试内容", 5);// 缓存有效期5秒
                logger.info("从Redis中读取数据:" + redisClient.getObject("test-key").toString());
                TimeUnit.SECONDS.sleep(3);
                logger.info("等待3秒后从Redis中读取数据:" + redisClient.getObject("test-key").toString());
                TimeUnit.SECONDS.sleep(3);
                logger.info("等待5秒后尝试读取过期的数据:" + redisClient.getObject("test-key"));
    
                redisClient.putObject("user",new User("张三","zs123"),10);
                logger.info("从Redis中读取数据User:" + redisClient.getObject("user"));
    
                List<String> list = new ArrayList<>();
                list.add("张飞");
                list.add("刘备");
                list.add("关于");
                redisClient.putObject("list",list,5);
                TimeUnit.SECONDS.sleep(3);
                logger.info("从Redis中读取数据User:" + redisClient.getObject("list"));
                TimeUnit.SECONDS.sleep(3);
                logger.info("从Redis中读取数据list:" + redisClient.getObject("list"));
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            return "OK";
        }
    }
    

    (5)运行测试结果

    2017-05-17 11:38:57.513 [http-nio-8080-exec-1] INFO  org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/] - Initializing Spring FrameworkServlet 'dispatcherServlet'
    2017-05-17 11:38:57.608 [http-nio-8080-exec-1] INFO  com.liutao.controller.UserController - 从Redis中读取数据:redis测试内容
    2017-05-17 11:39:00.608 [http-nio-8080-exec-1] INFO  com.liutao.controller.UserController - 等待3秒后从Redis中读取数据:redis测试内容
    2017-05-17 11:39:03.609 [http-nio-8080-exec-1] INFO  com.liutao.controller.UserController - 等待5秒后尝试读取过期的数据:null
    2017-05-17 11:39:03.612 [http-nio-8080-exec-1] INFO  com.liutao.controller.UserController - 从Redis中读取数据User:User{name='张三', password='zs123'}
    2017-05-17 11:39:06.614 [http-nio-8080-exec-1] INFO  com.liutao.controller.UserController - 从Redis中读取数据User:[张飞, 刘备, 关于]
    2017-05-17 11:39:09.614 [http-nio-8080-exec-1] INFO  com.liutao.controller.UserController - 从Redis中读取数据list:null

    三、总结

    从以上测试结果可以看出目前缓存已经生效。采用此方法不仅仅可以缓存字符串而且针对对象和集合都可以进行缓存。项目代码参考地址SpringBoot中使用redis缓存


    展开全文
  • 为什么使用Redis做缓存 MySQL缺点 单机连接数目有限 对数据进行写速度慢 Redis优点 内存操作数据速度快 IO复用,速度快 单线程模型,避免线程切换带来的开销,速度快 一致性问题  读数据的时候...

    为什么使用Redis做缓存

    MySQL缺点

    • 单机连接数目有限
    • 对数据进行写速度慢

    Redis优点

    • 内存操作数据速度快
    • IO复用,速度快
    • 单线程模型,避免线程切换带来的开销,速度快

    一致性问题

      读数据的时候首先去Redis里读,没有读到再去MySQL里读,读回来之后更新到Redis里作为下一次的缓存。写数据的时候回产生数据不一致的问题,无论是先写到Redis里再写MySQL还是先写MySQL再写Redis,这两步写操作不能保证原子性,所以会出现Redis和MySQL里的数据不一致。无论采取何种方式都不能保证强一致性,如果对Redis里的数据设置了过期时间能够保证最终一致性,对架构做的优化只能降低不一致性发生的概率,不能从根本上避免不一致性。

      根据写入的顺序不同分为四种。

     

    先删缓存,再更新数据库

      这种操作的问题?

      一般考虑某种策略的问题都是考虑该种策略会不会导致被删除的脏数据由于时序混乱再次被读线程从MySQL中读出来。A线程写数据,B线程读数据,A线程删除了缓存,B线程读数据发现缓存没有命中从数据库中读数据,B线程把读出的旧数据写到Redis里,A线程把新数据写回去。和下面的先写数据库再删缓存相比,这种方式显著的缺点

    • 先删缓存,所以当两个线程并发的时候很大几率会出现缓存不命中,一旦缓存不命中,在写线程修改MySQL完成之前读进来的永远是脏数据
    • 在缓存到期之前Redis里一直是脏数据

      解决策略

      延迟双删,双删就是在更新完数据库后再删一次。不过延迟双删中更新数据库之前的删除还有什么意义?延迟的目的是为了删除在写MySQL期间读线程可能把脏数据再次读到Redis里,延迟的时间参照一次从MySQL读数据并写入Redis的时间

     

    Cache Aside Pattern--先写数据库,再删缓存

      为什么更新数据库后不更新而是删除缓存?

    • 更新缓存的操作不是必须的。可能缓存里的数据并没有被读到,就会被下一次更新MySQL操作带来Redis更新操作覆盖,那么本次更新操作就是无意义的。
    • 更新缓存代价大。如果缓存里的数据不是把MySQL里的数据直接存下来,而是需要经过某种复杂的运算,那么这种不必要的更新会带来更大的浪费。

      这种操作的问题?

    • 并发问题。A线程读数据但没有命中,B线程写数据。A线程读到了MySQL的旧数据,B线程写了新的数据进MySQL,B线程删除了Redis中旧数据的缓存,A用旧数据写到了Redis缓存里。此时Redis里就是旧的脏数据。但这种case出现的概率较低,需要Redis缓存失效同时出现线程写入操作,而且理论上A线程从MySQL中读数据应该更快的返回。

      解决方案?

      每个写MySQL线程写完后延时一定时间在去删Redis中的缓存。

     

    Write Behind Caching Pattern--只更缓存,不更MySQL,MySQL由缓存异步的更新

     

      

      

     

    转载于:https://www.cnblogs.com/AshOfTime/p/10815593.html

    展开全文
  • 自己也用过一段时间的mongodb数据库,所以就像个对比,来看一看优缺点。 mongoDB与关系型数据库 优点 弱一致性(最终一致),更能保证用户的访问速度。 举例来说,在传统的关系型数据库中,一个COUNT类型的操作...

    前言:
    自己也用过一段时间的mongodb数据库,所以就像做个对比,来看一看优缺点。

    mongoDB与关系型数据库

    优点

    1. 弱一致性(最终一致),更能保证用户的访问速度。

    举例来说,在传统的关系型数据库中,一个COUNT类型的操作会锁定数据集,这样可以保证得到“当前”情况下的较精确值。这在某些情况下,例 如通过ATM查看账户信息的时候很重要,但对于Wordnik来说,数据是不断更新和增长的,这种“较精确”的保证几乎没有任何意义,反而会产生很大的延 迟。他们需要的是一个“大约”的数字以及更快的处理速度。
    但某些情况下MongoDB会锁住数据库。如果此时正有数百个请求,则它们会堆积起来,造成许多问题。我们使用了下面的优化方式来避免锁定:
    每次更新前,我们会先查询记录。查询操作会将对象放入内存,于是更新则会尽可能的迅速。在主/从部署方案中,从节点可以使用“-pretouch”参数运行,这也可以得到相同的效果。
    使用多个mongod进程。我们根据访问模式将数据库拆分成多个进程。

    1. 文档结构的存储方式,能够更快捷的获取数据
      对于一个层级式数据结构来说,如果要将这样的数据使用扁平式的,表状的结构来保存数据,这无论是在查询还是获取数据时都是十分困难的。

    2. 内置GridFS,支持大容量的存储。
      GridFS是一个出色的分布式文件系统,可以支持海量的数据存储。
      内置了GridFS了MongoDB,能够满足对大数据集的快速范围查询。

    3. 内置Sharding。
      提供基于Range的Auto Sharding机制:一个collection可按照记录的范围,分成若干个段,切分到不同的Shard上。
      Shards可以和复制结合,配合Replica sets能够实现Sharding+fail-over,不同的Shard之间可以负载均衡。查询是对 客户端是透明的。客户端执行查询,统计,MapReduce等操作,这些会被MongoDB自动路由到后端的数据节点。这让我们关注于自己的业务,适当的 时候可以无痛的升级。MongoDB的Sharding设计能力较大可支持约20 petabytes,足以支撑一般应用。
      这可以保证MongoDB运行在便宜的PC服务器集群上。PC集群扩充起来非常方便并且成本很低,避免了“sharding”操作的复杂性和成本。

    4. 第三方支持丰富。(这是与其他的NoSQL相比,MongoDB也具有的优势)
      现在网络上的很多NoSQL开源数据库完全属于社区型的,没有官方支持,给使用者带来了很大的风险。
      而开源文档数据库MongoDB背后有商业公司10gen为其提供供商业培训和支持。
      而且MongoDB社区非常活跃,很多开发框架都迅速提供了对MongDB的支持。不少知名大公司和网站也在生产环境中使用MongoDB,越来越多的创新型企业转而使用MongoDB作为和Django,RoR来搭配的技术方案

    5. 性能优越
      在使用场合下,千万级别的文档对象,近10G的数据,对有索引的ID的查询不会比mysql慢,而对非索引字段的查询,则是全面胜出。 mysql实际无法胜任大数据量下任意字段的查询,而mongodb的查询性能实在让我惊讶。写入性能同样很令人满意,同样写入百万级别的数 据,mongodb比我以前试用过的couchdb要快得多,基本10分钟以下可以解决。补上一句,观察过程中mongodb都远算不上是CPU杀手。

    缺点

    1. mongoDB不支持事务
      所以事务要求严格的系统(如果银行系统)肯定不能用它。(这点和优点①是对应的)

    2. mongodb占用空间过大。
      关于其原因,在官方的FAQ中,提到有如下几个方面:
      1、空间的预分配:为避免形成过多的硬盘碎片,mongodb每次空间不足时都会申请生成一大块的硬盘空间,而且申请的量从64M、128M、256M那 样的指数递增,直到2G为单个文件的较大体积。随着数据量的增加,你可以在其数据目录里看到这些整块生成容量不断递增的文件。
      2、字段名所占用的空间:为了保持每个记录内的结构信息用于查询,mongodb需要把每个字段的key-value都以BSON的形式存储,如果 value域相对于key域并不大,比如存放数值型的数据,则数据的overhead是较大的。一种减少空间占用的方法是把字段名尽量取短一些,这样占用 空间就小了,但这就要求在易读性与空间占用上作为权衡了。我曾建议作者把字段名作个index,每个字段名用一个字节表示,这样就不用担心字段名取多长 了。但作者的担忧也不无道理,这种索引方式需要每次查询得到结果后把索引值跟原值作一个替换,再发送到客户端,这个替换也是挺耗费时间的。现在的实现算是 拿空间来换取时间吧。
      3、删除记录不释放空间:这很容易理解,为避免记录删除后的数据的大规模挪动,原记录空间不删除,只标记“已删除”即可,以后还可以重复利用。
      4、可以定期运行db.repairDatabase()来整理记录,但这个过程会比较缓慢

    3. MongoDB没有如MySQL那样成熟的维护工具,这对于开发和IT运营都是个值得注意的地方。
      MongoDB适合存储一些关系简单、数据量又很大的数据,比如我们的平台上虚拟机的监控信息,包括内存、IO、CPU、网络等数据,每隔几秒就采集一次数据,每周、每月,量很大,而且旧的监控数据也不会保留太长时间,就使用的mongodb来存储这些数据;
      另外mongodb的集群部署相对比较简单,易于扩展;比如主从复制,在mongo.conf配置几个参数就OK了;分片集群的配置也比较简单。还支持使用命令行来进行动态地添加和删除节点;

    MongoDB优点与不足

    1. 不足之处
    • 在集群分片中的数据分布不均匀
    • 单机可靠性比较差
    • 大数据量持续插入,写入性能有较大波动
    • 磁盘空间占用比较大
    1. 过人之处
    • 无模式
    • 查询与索引方式灵活,是最像SQL的Nosql。
    • 支持复制集、主备、互为主备、自动分片等特性。

    MongoDB与redis比较

    • MongoDB源码是C++语言,redis源码是C语言。
    • MongoDB文件存储是BSON格式类似JSON,或自定义的二进制格式。
    • MongoDB性能都很依赖于内存的大小,MongoDB有丰富的数据表达、索引;最类似于关系数据库,支持丰富的查询语言,redis数据丰富,较少的IO,这方面mongoDB优势明显。
    • MongoDB不支持事务,靠客户端自身保证,redis支持事务,不过比较弱,仅能保证事务中的操作按顺序执行,这方面redis由于mongoDB.
    • mongoDB对海量数据的访问效率提升,redis较小数据量的性能及运算,这方面MongoDB性能优于redis。monbgodb 有mapredurce功能,提供数据分析,redis 没有 ,这方面 mongodb优于redis 。
    展开全文
  • Redis做缓存是很常见的应用场景。如果客户端请求在缓存层命中就直接返回,如果没有命中就去读取存储层,存储层读取到后就写入缓存层,然后再返回到客户端。 缓存的优点:加速读写的速度、降低后端负载 缓存的缺点:...

    1.缓存

    在这里插入图片描述
    Redis做缓存是很常见的应用场景。如果客户端请求在缓存层命中就直接返回,如果没有命中就去读取存储层,存储层读取到后就写入缓存层,然后再返回到客户端。
    缓存的优点:加速读写的速度、降低后端负载
    缓存的缺点:数据的不一致性、代码维护成本增大

    2.缓存穿透优化

    什么是缓存穿透?
    请求cache拿不到数据,就会去存储层拿,都拿不到时,返回空值(可能会返回大量空值)。或者代码有问题,拿不到数据,就会一直请求数据,导致后端over。
    简单的说就是去Redis中找数据,没有找到 ,然后去MySQL中找数据 还是没找到。这时如果不做任何处理,后面的所有的这个操作 都会访问MySQL,这样MySQL就会被Over掉,这种现象就称为缓存穿透。
    如何解决?
    缓存层缓存空值:当去MySQL中找数据时,如果没有找到,那么直接返回一个为“”的字符串, 表明有数据,只是值为“”而已,这样后面所有的线程就不会再去访问MySQL了。
    在这里插入图片描述

    3.缓存雪崩优化

    什么是缓存雪崩?
    1、Redis死了,那么所有请求都会去 请求MySQL,这个时候MySQL无法承载压力,也会Over。
    2、大量的key同时过期,这个时候就会造成大量的请求去访问MySQL,这样MySQL也可能被over
    简单说就是redis挂了,客户端直接请求到数据库里面,数据库负载非常高,甚至把数据库拖挂了。
    在这里插入图片描述

    解决方法:
    1、保持缓存层服务器的高可用。
    监控、集群、哨兵。当一个集群里面有一台服务器有问题,让哨兵踢出去。
    2、依赖隔离组件为后端限流并降级。
    比如推荐服务中,如果个性化推荐服务不可用,可以降级为热点数据。
    3、提前演练。
    演练缓存层crash后,应用以及后端的负载情况以及可能出现的问题。

    展开全文
  • redis缓存的数据类型分析 字符串(string): 优点:字符串存储节省内存 缺点:序列化转换(读写过程需要数据的转换处理)消耗时间,更新操作不方便。 其他类型(hash、set、zset、list): 优点:读写时不需要...
  • 接上节,上节讲解了RDB持久化,接下来我们讲解AOF持久化,并比较两者的优点缺点。告诉您企业里面怎么持久化。 2.3. AOF持久化 ​ AOF机制对每条写入命令以append-only的模式写入一个日志文件中,在redis重启的...
  • mybatis 自定义redis做二级缓存 前言 如果关注功能实现,可以直接看功能实现部分 何时使用二级缓存 一个宗旨---不常变的稳定而常用的 一级是默认开启的sqlsession级别的。 只在单表中使用,且所有的操作都是一个...
  • 缺点:若过期key很多,删除这些key会占用很多的CPU时间,在CPU时间紧张的情况下,CPU不能把所有的时间用来要紧的事儿,还需要去花时间删除这些key。定时器的创建耗时,若为每一个设置过期时间的key创建一个定时器...
  • 文章目录Redis 用作数据库一、持久化之RDB1、时点性2、RDB配置3、优缺点RDB的优点RDB的缺点二、持久化之AOF1、AOF配置2、优缺点AOF 优点AOF 缺点 Redis 用作缓存,其特点之一就是数据可以丢,只需要保证其响应急速,...
  • redis之雪崩问题的解决:首先redis做缓存,应用场景一般如下: Redis做缓存是最常见的应用场景。客户端请求在缓存层命中就直接返回,如果miss就去读取存储层,存储层读取到就写入缓存层,然后再返回到客户端。  ...
  • 文章目录一、redis的基本介绍1.1、redis简介:1.2、redis的优点1.3、redis的缺点1.4、redis速度快的原因1.5、redis的应用场景...2.5、有序集合Zset三、redis做缓存使用3.1、redis的持久化方案3.1.1、RDB模式3.1.2、A...
  • redis之雪崩问题的解决:首先redis做缓存,应用场景一般如下: Redis做缓存是最常见的应用场景。客户端请求在缓存层命中就直接返回,如果miss就去读取存储层,存储层读取到就写入缓存层,然后再返回到客户端。  ...
  • 与传统的数据库不同的是redis的数据是存在内存的,所以读写性能不是一般的高,可达到每秒10万次操作,因此被广泛的应用到缓存方向,例如:在网站架构里面和tomcatsession共享,数据库缓存等。Redis的优缺点优点...
  • 1基础 1.1redis 提供海量数据存储访问 ... 一般存数据,做缓存 1.3缓存方案对比 1.3.1Ehcache=》适合单应用 优点: 基于java开发 基于JVM缓存 简单、轻巧、方便 缺点: 集群不支持 分布式不支
  • redis面试复习.xmind

    2020-05-11 19:55:34
    ### 写了快照和命令行模式的优点缺点 (按道理的话本应该写上快照模式的自动和手动,save和bgsave等等,但是这里掌握的还不是很熟练所以暂未完善) # redis常见并发问题 ### 雪崩,击穿,击穿的概念与解决方案 ### 解决...
  • Redis 数据持久化

    2018-04-04 15:58:00
    Redis 一般用来做缓存服务,有时如果需要将数据持久化,目前也提供两种方式来持久化Redis数据。  持久化的优点:  服务挂掉后能从持久化的文件中快速恢复  缺点:  会有性能上的损失 RDB  从Redis主进程...
  • Redis常见面试题汇总1

    2020-10-06 10:28:23
    Redis的数据存储在缓存中,所以读写速度快,每秒可以处理10万次读写操作,Redis经常用来分布式锁,除此之外Redis支持事务、持久化、LUA脚本、LRU驱动事件、多种集群方案。 2.Redis的优缺点 优点: 1.读写性能...
  • Redis做缓存是最常见的应用场景。客户端请求在缓存层命中就直接返回,如果miss就去读取存储层,存储层读取到就写入缓存层,然后再返回到客户端。 优点: 加速读写 降低后端负载 缺点: 数据的不一致性 代码维护成本 ...
  • Redis Mode 工作模式

    2021-02-24 14:34:07
    我们项目接触redis一开始是作为缓存,主要是因为它的速度快。其次是用于分布式锁,如果有兴趣还可以用来布隆过滤器。 redis的模式基本分4种,在实际 生产环境中,主要还是集群。 讨论的redis版本,以4.0为主。 单...
  • Redis知识总结

    2018-12-15 13:37:50
    redis是基于内存,常用作缓存的一种技术,存储方式以key-value形式,但是内部实现数据结构是hash表,每创建一个数据时,分别创建两个hash数据,保存key与value,key一定为字符串 优点:速度快,性能优越,支持多种...
  • Redis在项目中如何使用及相关知识?

    千次阅读 2019-04-05 09:59:24
    1.1 做缓存,一些经常查询的数据又不会修改的数据就可以放在redis中; 1.2 可以做redis队列,比如短信邮件可以放入到redis队列中。 1.3 redis-session共享 缺点:数据多了会消耗内存, 优点:但是查询...
  • Redis入门命令及演示

    2021-04-08 22:23:34
    redis定位是缓存, 提高数据读写速度, 减轻对数据库存储与访问压力。 优点: ​ 读写速度快 ​ 支持丰富的数据类型 ​ 对数据有可拓展性和高可用性 ​ 单线程操作,每个操作都是原子操作,没有并发相关问题 缺点: ​ ...
  • springboot项目本身有一个redis cluster集群配置,,主要用于存储用户的token还有一些常用数据查询的缓存。这个项目本身有token认证,但是这个项目又隶属于集团公司下的一个子系统,领导要求集团公司的单点登录...
  • 前言咱们以前讲了Redis缓存雪崩、穿透、击穿。在文章里咱们说了解决缓存穿透的办法之一,就是布隆过滤器,可是上次并无讲如何使用布隆过滤器。java为暖男的老哥,给大家补上,请叫我IT老暖男。web 什么是布隆...
  • 02 : redis 数据持久化

    2019-10-08 06:21:55
    Redis数据持久化 什么是持久化: 通俗点:就是把redis缓存在内存中的数据保存到磁盘文件里面。...优点:速度快,适合于用备份,主从复制也是基于RDB持久化功能实现的。 缺点:会有数据丢失 AOF 持久化 记...
  • 目录 一、概述 ...如果我们的Redis服务器只作为缓存使用,Redis中存储的所有数据都是从其他地方同步过来的备份,那么就没必要开启数据持久化的选项,但是如果我们希望将内存中的数据保留下来的...
  • 探索redis数据过期策略

    千次阅读 2019-03-19 16:35:46
    1.过期设置为程序逻辑的一部分,所以为了保证逻辑正确(不读取到过期数据),不得不对缓存做数据过期处理 2.过期数据,对业务来说已是无用数据,但是却仍然占有服务资源(主要是内存和磁盘),故处理过期数据,将其删除...
  • redis 非关系型数据库,也是一个内存数据库。 那这就会存在两个问题:1....优点:多用于缓存,可以实现快速读写操作。 缺点:存储格式是key-value类型,只能等值查询,也就是说只能通过key查找到...

空空如也

空空如也

1 2 3
收藏数 45
精华内容 18
关键字:

redis做缓存优点缺点

redis 订阅