精华内容
下载资源
问答
  • 在本文中,我们将讨论如何使用第三方redis java客户机利用java和redis中的本地缓存 什么是本地缓存缓存是内存缓冲区,用于将数据存储在一个方便的位置,以便以后对该数据的请求能够更快地执行。 在本地缓存中,...

    本地缓存是提高Redis等数据库性能的最有用的策略之一。希望在Java中进行本地缓存的Redis开发人员会发现Redis不支持这一功能。在本文中,我们将讨论如何使用第三方redis java客户机利用java和redis中的本地缓存
    什么是本地缓存?
    缓存是内存缓冲区,用于将数据存储在一个方便的位置,以便以后对该数据的请求能够更快地执行。
    在本地缓存中,数据库中最常用的数据在物理上存储在离访问它的应用程序更近的地方,存储库称为本地缓存…例如,如果应用程序运行在经常访问数据库服务器的客户端上,本地缓存可能存储在客户机自己的硬盘上,从而消除了网络延迟通过在本地缓存中更接近地存储数据,可以显着地加快响应时间并减少网络流量;但是,还需要小心地处理本地缓存,以确保本地缓存中存储的数据与原始数据库中的数据保持一致。
    用Java在Redis中进行本地缓存
    开发人员可以很容易地实现本地内存。Java中的缓存,无论是使用内置Java数据结构(如HashMaps)还是使用第三方Java库。
    当开发人员希望在Redis中使用这些本地缓存特性时,问题就出现了,因为Redis并不自动支持Java编程语言的使用。
    幸运的是,有一个简单的解决方案:开发人员可以在Redis项目中使用第三方Java框架(如redisson)。Redisson是Redis的Java客户端,它提供了数十个分布式Java对象和服务。这使得熟悉标准Java类和接口的开发人员更容易使用Redis学习曲线。
    在接下来的几节中,我们将讨论开发人员可以使用Redisson在Redis中实现Java本地缓存的几种方法。
    在带有地图的Redis和Java中进行本地缓存
    Java中的映射表示键值对之间的映射;它们是在Java中实现本地缓存的最简单方法之一。
    Redisson中的RLocalCachedMap接口扩展了Java的内置ConcurrentMap接口,包括对Redis中的本地缓存的支持。此本地缓存使应用程序能够执行比正常速度快45倍的读取操作。
    用户可以配置以下RLocalCachedMap功能:
    · 最大缓存大小。
    · 每个缓存条目的存活时间。
    · 每个缓存条目的最大空闲时间。
    · 缓存项的驱逐策略。
    · 缓存更改的同步策略。
    下面是如何在Redisson中使用RLocalCachedMap的示例:

    RLocalCachedMap<String, Integer> map = redisson.getLocalCachedMap("test", LocalCachedMapOptions.defaults()); 
       String prevObject = map.put("123", 1);
     String currentObject = map.putIfAbsent("323", 2);
     String obj = map.remove("123");
        // use fast* methods when previous value is not required map.fastPut("a", 1); 
    map.fastPutIfAbsent("d", 32); map.fastRemove("b");
        RFuture<String> putAsyncFuture = map.putAsync("321");
     RFuture<Void> fastPutAsyncFuture = map.fastPutAsync("321"); 
       map.fastPutAsync("321", new SomeObject());
     map.fastRemoveAsync("321");

    如果RLocalCachedMap不再使用,建议显式销毁该映射;但是,如果Redisson关闭,则这一点并不是绝对必要的:

    RLocalCachedMap<String, Integer> map = ... 
    map.destroy(); 

    使用SpringCache的Redis和Java本地缓存
    Redisson还支持用于本地缓存的三个第三方Java框架:弹簧缓存、Hibernate缓存和JCache。
    Spring与Redisson框架完全兼容,Redisson通过RedissonSpringLocalCachedCacheManager类支持SpringCache。用户可以配置以下功能:
    · 最大缓存大小。
    · 每个缓存条目的存活时间。
    · 每个缓存条目的最大空闲时间。
    · 重新连接策略。
    · 缓存更改的同步策略。
    下面是如何在Redisson中配置Spring缓存的示例:

     @Configuration 
         @ComponentScan 
        @EnableCaching 
        public static class Application {
                @Bean(destroyMethod="shutdown")
             RedissonClient redisson() throws IOException {
                 Config config = new Config();
                 config.useClusterServers()
                       .addNodeAddress("redis://127.0.0.1:7004", "redis://127.0.0.1:7001");
                 return Redisson.create(config);
             }
                @Bean 
            CacheManager cacheManager(RedissonClient redissonClient) {
                 Map<String, CacheConfig> config = new HashMap<String, CacheConfig>(); 
                   // define local cache settings for "testMap" cache. 
                // ttl = 48 minutes and maxIdleTime = 24 minutes for local cache entries
                 LocalCachedMapOptions options = LocalCachedMapOptions.defaults()
                     .evictionPolicy(EvictionPolicy.LFU)
                     .timeToLive(48, TimeUnit.MINUTES)
                     .maxIdle(24, TimeUnit.MINUTES);
                     .cacheSize(1000); 
                   // create "testMap" Redis cache with ttl = 24 minutes and maxIdleTime = 12 minutes 
                config.put("testMap", new LocalCachedCacheConfig(24*60*1000, 12*60*1000, options));
                 return new RedissonSpringLocalCachedCacheManager(redissonClient, config);
             }
            } 

    使用Hibernate缓存的Redis和Java本地缓存
    Hibernate缓存是Redisson中的第二个第三方Java本地缓存选项。Hibernate中的缓存是通过RedissonLocalCachedRegionFactory类在Redisson中完成的。用户可以配置以下功能:
    · 最大缓存大小。
    · 每个缓存条目的存活时间。
    · 每个缓存条目的最大空闲时间。
    · 缓存项的驱逐策略。
    · 重新连接策略。
    · 缓存更改的同步策略。
    在带有JCache的Redis和Java中进行本地缓存
    最后,还可以使用Redisson和JCache在Redis中执行Java本地缓存。配置缓存是通过LocalCacheConfiguration类在JCache实例初始化期间完成的。用户可以配置以下功能:
    · 最大缓存大小。
    · 每个缓存条目的存活时间。
    · 每个缓存条目的最大空闲时间。
    · 缓存项的驱逐策略。
    · 重新连接策略。
    · 缓存更改的同步策略。
    下面是如何使用JCache和Redisson初始化Java本地缓存的示例:

    LocalCacheConfiguration<String, String> config = new LocalCacheConfiguration<>();
        CacheManager manager = Caching.getCachingProvider().getCacheManager();
     Cache<String, String> cache = manager.createCache("myCache", config);
        // or 
       URI redissonConfigUri = getClass().getResource("redisson-jcache.yaml").toURI();
     CacheManager manager = Caching.getCachingProvider().getCacheManager(redissonConfigUri, null);
     Cache<String, String> cache = manager.createCache("myCache", config); 
       // or 
        Config redissonCfg = ... Configuration<String, String> rConfig =
     RedissonConfiguration.fromConfig(redissonCfg, config);
        CacheManager manager = Caching.getCachingProvider().getCacheManager();
     Cache<String, String> cache = manager.createCache("namedCache", rConfig); 

    结语
    Redisson为Java开发人员在Redis中执行本地缓存提供了多种选项:map、SpringCache、Hibernate缓存和JCache。
    请注意,最后三个选项–Spring缓存、Hibernate缓存和JCache–仅供Redisson专业用户使用。Redisson pro包括各种特性和性能增强,使其有别于Redisson的开源版本。这包括集群模式下的数据分区、XA事务、多线程应用程序的超高速速度和24x7支持。
    感谢您的阅读。对文章如有疑问,欢迎提出。望分享的内容对大家有所帮助。搜集整理了一些Java资料,包括Java进阶学习路线以及对应学习资料,还有一些大厂面试题,需要的朋友可以自行领取:Java高级架构学习资料分享+架构师成长之路
    顺便给大家推荐一个Java技术交流群:473984645里面会分享一些资深架构师录制的视频资料:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多!

    展开全文
  • Guava Cache本地缓存 Redis分布式缓存

    Guava Cache本地缓存

     

    Redis分布式缓存

    展开全文
  • Ehcache缓存和Redis缓存数据

    千次阅读 2020-07-19 11:46:11
    SpringBoot中使用JVM缓存 pom <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> ehcache.xml &...

    JVM缓存和使用Redis缓存数据

    一、本地缓存Ehcache

    Ehcache是纯java的开源缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。它主要面向通用缓存、Java EE和轻量级容器,具有内存和磁盘存储、缓存加载器、缓存扩展、缓存异常处理程序。
     Ehcache最初由Greg Luck于2003年开始开发。2009年,该项目被Terracotta购买。软件仍然开源,但一些新的主要功能(例如,快速可重启性之间的一致性的)只能在商业产品中使用。
    Ehcache 被广泛用于在Hibernate、Spring、Cocoon等其他开源系统。

    1. Ehcache的主要特性

    1. 快速;
    2. 简单;
    3. 多种缓存策略;
    4. 缓存数据有两级:内存和磁盘,因此无需担心容量问题;
    5. 缓存数据会在虚拟机重启的过程中写入磁盘;
    6. 可以通过 RMI、可插入 API 等方式进行分布式缓存;
    7. 具有缓存和缓存管理器的侦听接口;
    8. 支持多缓存管理器实例,以及一个实例的多个缓存区域;
    9. 提供 Hibernate 的缓存实现;

    2. Ehcache缓存过期策略

    当缓存需要被清理时(比如空间占用已经接近临界值了),需要使用某种淘汰算法来决定清理掉哪些数据。常用的淘汰算法有下面几种:

    1. FIFO:First In First Out,先进先出。判断被存储的时间,离目前最远的数据优先被淘汰。
    2. LRU:Least Recently Used,最近最少使用。判断最近被使用的时间,目前最远的数据优先被淘汰。
    3. LFU:Least Frequently Used,最不经常使用。在一段时间内,数据被使用次数最少的,优先被淘汰。

    3. 主要注解

    @CachePut 是将数据加入到redis缓存中

    @Cacheable 在获取数据的时候会先查询缓存,如果缓存中存在,则不执行查询数据库的方法,如果不存在则查询数据库,并加入到缓存中。
    @CacheEvict 一般注解到删除数据的操作上,会将一条或多条数据从缓存中删除。

    4. SpringBoot中使用Ehcache

    1. pom
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    
    <dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache</artifactId>
    </dependency>
    
    1. application.yml
    server:
      port: 8081
    
    spring:
      datasource:
        url: jdbc:mysql://localhost:3306/db1
        username: root
        password: root
        driver-class-name: com.mysql.jdbc.Driver
    
      cache:
        type: ehcache
        ehcache:
          config: classpath:ehcache.xml
    
    1. ehcache.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
    	updateCheck="false">
    	<diskStore path="java.io.tmpdir/Tmp_EhCache" />
    
    
    	<defaultCache maxElementsInMemory="5000" eternal="false"
    		timeToIdleSeconds="120" timeToLiveSeconds="120"
    		memoryStoreEvictionPolicy="LRU" overflowToDisk="false" />
    
    
    	<cache name="userCache" maxElementsInMemory="1000" eternal="false"
    		timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true"
    		diskSpoolBufferSizeMB="30" maxElementsOnDisk="10000000"
    		diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
    		memoryStoreEvictionPolicy="LRU">
    		<cacheEventListenerFactory
    			class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" />
    		
    		<bootstrapCacheLoaderFactory
    			class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory" />
    	</cache>
    
    </ehcache>
    
    1. 启动
    @EnableCaching
    @SpringBootApplication
    public class App {
    	public static void main(String[] args) {
    		SpringApplication.run(App.class, args);
    	}
    }
    
    1. 使用
    @CacheConfig(cacheNames = "userCache")
    public interface UserMapper {
    	@Select("select * from users where name=#{name}")
    	@Cacheable
    	UserEntity findName(@Param("name") String name);
    }
    
    @CacheConfig(cacheNames = "transitoryCache")
    @RestController
    public class TestController {
    
        @GetMapping("/GetTest/{id}/{param}")
        @Cacheable(key = "#id.toString()")
        public String getTest(@PathVariable("id")String id,@PathVariable("param")String param){
            return "参数->"+param;
        }
    
        @GetMapping("/UpdateDate/{id}/{param}")
        @CachePut(key = "#id.toString()")
        public String updateDate(@PathVariable("id")String id,@PathVariable("param")String param){
            return "参数->"+param;
        }
    
        @GetMapping("/DeleteDate/{id}")
        @CacheEvict(key = "#id.toString()")
        public String deleteDate(@PathVariable("id")String id){
            return "success";
        }
    
    }
    

    清楚缓存

    @Autowired
    private CacheManager cacheManager;
    @RequestMapping("/remoKey")
    public void remoKey() {
    	cacheManager.getCache("userCache").clear();
    }
    

    二、Redis缓存

    springboot已经集成了redis缓存,只需要在pom.xml中加载redis,然后通过注解即可完成配置。

    springboot 集成

    1. pom
      		<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>
    
    1. application.yml 修改
    server:
      port: 8080
    
    spring:
      cache:
        type: redis
    
    1. 启动类
    @SpringBootApplication
    @EnableCaching
    @MapperScan(value = {"com.bxc.rediscaching.Mapper"})
    public class RediscachingApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(RediscachingApplication.class, args);
        }
    }
    
    1. service
    @Service
    public class UserService {
        @Autowired
        UserMapper userMapper;
    
        @Cacheable(key = "#root.methodName",value = "userCache")
        public List<UserEntity> getAllUser(){
            System.out.println();
            List<UserEntity> list = userMapper.selectList(null);
            return list;
        }
    	
    	 //@Cacheable 表示可缓存,如果缓存中存在,就从缓存中查询,不存在,就走数据库
        //其中缓存库位userCache,key表示使用缓存的key(为当前的传递的id.toString())
        @Cacheable(key = "#id.toString()", value = "userCache")
        public UserEntity findUserById(Integer id) {
            System.out.println("从数据库中查询编号为:"+id);
            return userData.get(id);;
            return null;
        }
    
       //表示向缓存中直接添加数据,添加的库为当前的value,添加的key为当前的key(user的id.toString())
        @CachePut(key = "#user.id.toString()", value = "userCache")
        public void addUser(UserEntity user) {
          userData.put(user.getId(), user);
        }
    
      //表示向缓存中直接添加数据,添加的库为当前的value,添加的key为当前的key(user的id.toString())
        @CachePut(key = "#user.id.toString()", value = "userCache")
        public void updateUser(UserEntity user) {
            userData.put(user.getId(), user);
        }
    
       //用来删除数据,指定key表示删除缓存库中的key的字段的内容,value表示删除的缓存的库
        @CacheEvict(key = "#id.toString()", value = "userCache")
        public void deleteUserById(Integer id) {
            userData.remove(id);
        }
    
     
         //用来删除数据,指定allEntries = true表示删除所有的缓存,value表示删除的缓存的库
        @CacheEvict(allEntries = true, value = "userCache")
        public void clearCache() {
            System.out.println("清空缓存");
        }
    
    }
    
    

    三、补充

    1. @Cacheable 和 @CachePut注解属性说明

    1. keyGenerator:缓存数据key生成策略;
    2. CacheManager:缓存管理器,管理缓存组件;
    3. CacheResolver:缓存解析器,根据实际情况动态解析决定使用哪个缓存实例;
    4. value:缓存实例(一个缓存实例可以存储多个缓存KV对)的名称,至少需要设置一个;
    5. key:缓存的 key,如果不为空需要要按照 SpEL 表达式编写;如果不为空6. 则缺省按照方法的所有参数进行组合;
    6. condition:缓存条件,使用 SpEL 编写;若不为空,只在条件结果为 true 时才进行缓存;
    7. unless:缓存排除条件,当条件结果为TRUE时不会缓存;
    8. sync:是否同步操作,如为true,那么多个线程访问同一条记录时,会同步执行调用的方法。

    2. @CacheEvict注解属性说明

    @CacheEvict注解的属性大致同 @Cacheable一致,不过 @CacheEvict还有两个独有的属性:

    1. allEntries:是否清空所有缓存内容,缺省为 false;如果指定为 true,则方法调用后将立即清空所有缓存;
    2. beforeInvocation:是否在方法执行前就清空,缺省为 false;如果指定为 true,则在方法还没有执行的时候就清空缓存,缺省情况下,如果方法执行抛出异常,则不会清空缓存。

    3. @CacheConfig注解属性说明

    @CacheConfig注解的属性 @Cacheable都有。因为 @CacheConfig注解的作用本来就是统一管理相同类下所有方法的缓存配置。

    需要提一下的就是在spring4.1之前是没有 @CacheConfig注解的,那时候需要在每个方法的 @Cacheable注解中设置cacheNames属性。

    4. SpEL表达式

    名称 位置 描述 示例
    methodName root对象 当前被调用的方法名 #root.methodname
    method root对象 当前被调用的方法 #root.method.name
    target root对象 当前被调用的目标对象实例 #root.target
    targetClass root对象 当前被调用的目标对象的类 #root.targetClass
    args root对象 当前被调用的方法的参数列表 #root.args[0]
    caches root对象 当前方法调用使用的缓存列表 #root.caches[0].name
    Argument Name 执行上下文 当前被调用的方法的参数,如findArtisan(Artisan artisan),可以通过#artsian.id获得参数 #artsian.id
    result 执行上下文 方法执行后的返回值(仅当方法执行后的判断有效,如 unless cacheEvict的beforeInvocation=false) #result

    注意事项:

    1. 当我们要使用root对象的属性作为key时我们也可以将“#root”省略,因为Spring默认使用的就是root对象的属性, 如 @Cacheable(key = “targetClass + methodName +#p0”);
    2. 使用方法参数时我们可以直接使用“#参数名”或者“#p参数index”,如: @Cacheable(value=“users”, key="#id")和 @Cacheable(value=“users”, key="#p0")。
    展开全文
  • 缓存redis面试题

    万次阅读 2020-10-11 12:42:41
    文章目录1、redis和memcached什么区别?为什么高并发下有时单线程的redis比多线程的memcached效率要高?2、redis主从复制如何实现的?redis的集群模式如何实现?redis的key是如何寻址的?3、使用redis如何设计分布式...

    文章目录

    1、redis和memcached什么区别?为什么高并发下有时单线程的redis比多线程的memcached效率要高?

    区别:

    1. memcached可缓存图片和视频。redis支持除k/v更多的数据结构;

    2. redis可以使用虚拟内存,redis可持久化和aof灾难恢复,redis通过主从支持数据备份;

    3.redis可以做消息队列。

    原因:memcached多线程模型引入了缓存一致性和锁,加锁带来了性能损耗。

    2、redis主从复制如何实现的?redis的集群模式如何实现?redis的key是如何寻址的?

    主从复制实现:主节点将自己内存中的数据做一份快照,将快照发给从节点,从节点将数据恢复到内存中。之后再每次增加新数据的时候,主节点以类似于mysql的二进制日志方式将语句发送给从节点,从节点拿到主节点发送过来的语句进行重放。

    分片方式:

    1. 客户端分片
    2. 基于代理的分片
    3. Twemproxy
    4. codis
    5. 路由查询分片
    6. Redis-cluster体身提供了自动将数据分散到RedisCluster不同节点的能力,整个数据集合的某个数据子集存储在哪个节点对于用户来说是透明的)
    7. redis-cluster分片原理:Cluster中有一个16384长度的槽(虚拟槽),编号分别为0-16383。每个Master节点都会负责一部分的槽,当有某个key被映射到某个Master负责的槽,那么这个Master负责为这个key提供服务,至于哪个Master节点负责哪个槽,可以由用户指定,也可以在初始化的时候自动生成,只有Master才拥有槽的所有权。Master节点维护着一个16384/8字节的位序列,Master节点用bit来标识对于某个槽自己是否拥有。比如对于编号为1的槽,Master只要判断序列的第二位(索引从0开始)是不是为1即可。这种结构很容易添加或者删除节点。比如如果我想新添加个节点D,我需要从节点A、B、C中得部分槽到D上。

    3、使用redis如何设计分布式锁?说一下实现思路?使用zk可以吗?如何实现?这两种有什么区别?

    redis:

    1. 线程Asetnx(上锁的对象超时时的时间戳tl),如果返回true,获得锁。

    2. 线程B用get获取t1,与当前时间戳比较,判断是是否超时,没超时false,若超时执行第3步;

    3. 计算新的超时时间t2,使用getset命令返回t3(该值可能其他线程已经修改过),如果t1==t3,获得锁,如果t1!=t3说明锁被其他线程获取了。

    4. 获取锁后,处理完业务逻辑,再去判断锁是否超时,如果没超时删除锁,如果已超时,不用处理(防止删除其他线程的锁)。

    zk:

    1. 客户端对某个方法加锁时,在zk上的与该方法对应的指定节点的目录下,生成一个唯一的瞬时有序节点node1;

    2. 客户端获取该路径下所有已经创建的子节点,如果发现自己创建的node1的序号是最小的,就认为这个客户端获得了锁。

    3. 如果发现node1不是最小的,则监听比自己创建节点序号小的最大的节点,进入等待。

    4. 获取锁后,处理完逻辑,删除自己创建的node1即可。区别:zk性能差一些,开销大,实现简单。

    4、知道redis的持久化吗?底层如何实现的?有什么优点缺点?

    RDB(RedisDataBase:在不同的时间点将redis的数据生成的快照同步到磁盘等介质上):内存到硬盘的快照,定期更新。缺点:耗时,耗性能(fork+io操作),易丢失数据。

    AOF(AppendOnlyFile:将redis所执行过的所有指令都记录下来,在下次redis重启时,只需要执行指令就可以了):写日志。缺点:体积大,恢复速度慢。

    bgsave做镜像全量持久化,aof做增量持久化。因为bgsave会消耗比较长的时间,不够实时,在停机的时候会导致大量的数据丢失,需要aof来配合,在redis实例重启时,优先使用aof来恢复内存的状态,如果没有aof日志,就会使用rdb文件来恢复。Redis会定期做aof重写,压缩aof文件日志大小。Redis4.0之后有了混合持久化的功能,将bgsave的全量和aof的增量做了融合处理,这样既保证了恢复的效率又兼顾了数据的安全性。bgsave的原理,fork和cow,fork是指redis通过创建子进程来进行bgsave操作,cow指的是copyonwrite,子进程创建后,父子进程共享数据段,父进程继续提供读写服务,写脏的页面数据会逐渐和子进程分囲开来。

    5、redis过期策略都有哪些?LRU算法知道吗?写一下java代码实现?

    过期策略:

    定时过期(一key一定时器),惰性过期:只有使用key时才判断key是否已过期,过期则清除。定期过期:前两者折中。

    LRU:newLinkedHashMap<K,V>(capacity,DEFAULT_LOAD_FACTORY,true);第三个参数置为true,代表linkedlist按访问顺序排序,可作为LRU缓存;设为false代表按插入顺序排序,可作为FIFO缓存

    LRU算法实现:

    1. 通过双向链表来实现,新数据插入到链表头部;

    2. 每当缓存命中(即缓存数据被访问),则将数据移到链表头部;

    3. 当链表满的时候,将链表尾部的数据丢弃。

    LinkedHashMap:HashMap和双向链表合二为一即是LinkedHashMap。HashMap是无序的,LinkedHashMap通过维护一个额外的双向链表保证了迭代顺序。该迭代顺序可以是插入顺序(默认),也可以是访问顺序。

    6、缓存穿透、缓存击穿、缓存雪崩解决方案?

    **缓存穿透:**指查询一个一定不存在的数据,如果从存储层查不到数据则不写入缓存,这将导致这个不存在的数据每次请求都要到DB去查询,可能导致DB挂掉。

    解决方案:

    1. 查询返回的数据为空,仍把这个空结果进行缓存,但过期时间会比较短;

    2. 布隆过滤器:将所有可能存在的数据哈希到一个足够大的bitmap中,一个一定不存在的数据会被这个bitmap拦截掉,从而避免了对DB的查询。

    **缓存击穿:**对于设置了过期时间的key,缓存在某个时间点过期的时候,恰好这时间点对这个Key有大量的并发请求过来,这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存,这个时候大并发的请求可能会瞬间把DB压垮。

    解决方案:

    1. 使用互斥锁:当缓存失效时,不立即去Ioaddb,先使用如Redis的setnx去设置一个互斥锁,当操作成功返回时再进行Ioaddb的操作并回设缓存,否则重试get缓存的方法。

    2. 永远不过期:物理不过期,但逻辑过期(后台异步线程去刷新)。缓存雪崩:设置缓存时采用了相同的过期时间,导致缓存在某一时刻同时失效,请求全部转发到DB,DB瞬时压力过重雪崩。与缓存击穿的区别:雪崩是很多key,击穿是某一个key缓存。

    解决方案:

    将缓存失效时间分散开,比如可以在原有的失效时间基础上增加一个随机值,比如1-5分钟随机,这样每一个缓存的过期时间的重复率就会降低,就很难引发集体失效的事件。

    7、在选择缓存时,什么时候选择redis,什么时候选择memcached

    选择redis的情况:

    1. 复杂数据结构,value的数据是哈希,列表,集合,有序集合等这种情况下,会选择redis,因为memcache无法满足这些数据结构,最典型的的使用场景是,用户订单列表,用户消息,帖子评论等。

    2. 需要进行数据的持久化功能,但是注意,不要把redis当成数据库使用,如果redis挂了,内存能够快速恢复热数据,不会将压力瞬间压在数据库上,没有cache预热的过程。对于只读和数据一致性要求不高的场景可以采用持久化存储

    3. 高可用,redis支持集群,可以实现主动复制,读写分离,而对于memcache如果想要实现高可用,需要进行二次开发。

    4. 存储的内容比较大,memcache存储的value最大为1M。

    选择memcache的场景:

    纯KV,数据量非常大的业务,使用memcache更合适,原因是:

    1. memcache的内存分配采用的是预分配内存池的管理方式,能够省去内存分配的时间,redis是临时申请空间,可能导致碎片化。

    2. 虚拟内存使用,memcache将所有的数据存储在物理内存里,redis有自己的vm机制,理论上能够存储比物理内存更多的数据,当数据超量时,引发swap,把冷数据刷新到磁盘上,从这点上,数据量大时,memcache更快

    3. 网络模型,memcache使用非阻塞的10复用模型,redis也是使用非阻塞的I。复用模型,但是redis还提供了一些非KV存储之外的排序,聚合功能,复杂的CPU计算,会阻塞整个I0调度,从这点上由于redis提供的功能较多,memcache更快些

    4. 线程模型,memcache使用多线程,主线程监听,worker子线程接受请求,执行读写,这个过程可能存在锁冲突。redis使用的单线程,虽然无锁冲突,但是难以利用多核的特性提升吞吐量。

    8、缓存与数据库不一致怎么办?

    假设采用的主存分离,读写分离的数据库,
    如果一个线程A先删除缓存数据,然后将数据写入到主库当中,这个时候,主库和从库同步没有完成,线程B从缓存当中读取数据失败,从从库当中读取到旧数据,然后更新至缓存,这个时候,缓存当中的就是旧的数据。

    发生上述不一致的原因在于,主从库数据不一致问题,加入了缓存之后,主从不一致的时间被拉长了。

    处理思路:在从库有数据更新之后,将缓存当中的数据也同时进行更新,即当从库发生了数据更新之后,向缓存发出删除,淘汰这段时间写入的旧数据。

    9、主从数据库不一致如何解决?

    场景描述,对于主从库,读写分离,如果主从库更新同步有时差,就会导致主从库数据的不一致

    1. 忽略这个数据不一致,在数据一致性要求不高的业务下,未必需要时时一致性

    2. 强制读主库,使用一个高可用的主库,数据库读写都在主库,添加一个缓存,提升数据读取的性能。

    3. 选择性读主库,添加一个缓存,用来记录必须读主库的数据,将哪个库,哪个表,哪个主键,作为缓存的key,设置缓存失效的时间为主从库同步的时间,如果缓存当中有这个数据,直接读取主库,如果缓存当中没有这个主键,就到对应的从库中读取。

    10、Redis常见的性能问题和解决方案

    1. 、master最好不要做持久化工作,如RDB内存快照和AOF日志文件

    2. 如果数据比较重要,某个slave开启AOF备份,策略设置成每秒同步一次

    3. 为了主从复制的速度和连接的稳定性,master和Slave最好在一个局域网内

    4. 尽量避免在压力大得主库上增加从库

    5. 主从复制不要米用网状结构,尽量是线性结构,Master<–Slave1<—Slave2…

    11、Redis的数据淘汰策略有哪些

    voltile-lru从已经设置过期时间的数据集中挑选最近最少使用的数据淘汰

    voltile-ttl从已经设置过期时间的数据库集当中挑选将要过期的数据

    voltile-random从已经设置过期时间的数据集任意选择淘汰数据

    allkeys-lru从数据集中挑选最近最少使用的数据淘汰

    allkeys-random从数据集中任意选择淘汰的数据

    no-eviction禁止驱逐数据

    12、Redis当中有哪些数据结构

    字符串String、字典Hash、列表List、集合Set、有序集合SortedSet。如果是咼级用户,那么还会有,如果你是Redis中高级用户,还需要加上下面几种数据结构HyperLogLog、Geo、Pub/Sub。

    13、假如Redis里面有1亿个key,其中有10w个key是以某个固定的已知的前缀开头的,如果将它们全部找出来?

    使用keys指令可以扫出指定模式的key列表。

    对方接着追问:如果这个redis正在给线上的业务提供服务,那使用keys指令会有什么问题?

    这个时候你要回答redis关键的一个特性:redis的单线程的。keys指令会导致线程阻塞一段时间,线上服务会停顿,直到指令执行完毕,服务才能恢复。这个时候可以使用scan指令,scan指令可以无阻塞的提取出指定模式的key列表,但是会有一定的重复概率,在客户端做一次去重就可以了,但是整体所花费的时间会比直接用keys指令长。

    14、使用Redis做过异步队列吗,是如何实现的

    使用list类型保存数据信息,rpush生产消息,lpop消费消息,当lpop没有消息时,可以sleep一段时间,然后再检查有没有信息,如果不想sleep的话,可以使用blpop,在没有信息的时候,会一直阻塞,直到信息的到来。redis可以通过pub/sub主题订阅模式实现一个生产者,多个消费者,当然也存在一定的缺点,当消费者下线时,生产的消息会丢失。

    15、Redis如何实现延时队列

    使用sortedset,使用时间戳做score,消息内容作为key,调用zadd来生产消息,消费者使用zrangbyscore获取n秒之前的数据做轮询处理。

    16、什么是Redis?简述它的优缺点?

    Redis本质上是一个Key-Value类型的内存数据库,很像memcached,整个数据库统统加载在内存当中进行操作,定期通过异步操作把数据库数据flush到硬盘上进行保存。

    因为是纯内存操作,Redis的性能非常出色,每秒可以处理超过10万次读写操作,是已知性能最快的Key-ValueDB。

    Redis的出色之处不仅仅是性能,Redis最大的魅力是支持保存多种数据
    结构,此外单个value的最大限制是1GB,不像memcached只能保存1MB的数据,因此Redis可以用来实现很多有用的功能。

    比方说用他的List来做FIFO双向链表,实现一个轻量级的高性能消息队列服务,用他的Set可以做高性能的tag系统等等。

    另外Redis也可以对存入的Key-Value设置expire时间,因此也可以被当作一个功能加强版的memcached来用。Redis的主要缺点是数据库容量受到物理内存的限制,不能用作海量数据的高性能读写,因此Redis适合的场景主要局限在较小数据量的高性能操作和运算上。

    17、Redis相比memcached有哪些优势?

    1. memcached所有的值均是简单的字符串,redis作为其替代者,支持更为丰富数据类型

    2. Redis的速度比memcached快很多

    3. redis可以持久化其数据

    18、Redis支持哪几种数据类型?

    String、List、Set、SortedSet、hashes

    19、Redis主要消耗什么物理资源?

    内存。

    20、Redis的全称是什么?

    Remote Dictionary Server

    21、Redis有哪几种数据淘汰策略?

    noeviction:返回错误当内存限制达到并且客户端尝试执行会让更多内存被使用的命令(大部分的写入指令,但DEL和几个例外)

    allkeys-lru:尝试回收最少使用的键(LRU),使得新添加的数据有空间存放。

    volatile-lru:尝试回收最少使用的键(LRU),但仅限于在过期集合的键,使得新添加的数据有空间存放。

    allkeys-random:回收随机的键使得新添加的数据有空间存放。

    volatile-random:回收随机的键使得新添加的数据有空间存放,但仅限于在过期集合的键。

    volatile-ttl:回收在过期集合的键,并且优先回收存活时间(TTL)较短的键,使得新添加的数据有空间存放。

    22、Redis官方为什么不提供Windows版本?

    因为目前Linux版本已经相当稳定,而且用户量很大,无需开发windows版本,反而会带来兼容性等问题。

    23、一个字符串类型的值能存储最大容量是多少?

    512M

    24、为什么Redis需要把所有数据放到内存中?

    Redis为了达到最快的读写速度将数据都读到内存中,并通过异步的方式将数据写入磁盘。

    所以redis具有快速和数据持久化的特征。如果不将数据放在内存中,磁盘I/O速度为严重影响redis的性能。

    在内存越来越便宜的今天,redis将会越来越受欢迎。如果设置了最大使用的内存,则数据已有记录数达到内存限值后不能继续插入新值。

    25、Redis集群方案应该怎么做?都有哪些方案?

    1. codis。
      目前用的最多的集群方案,基本和twemproxy一致的效果,但它支持在节点数量改变情况下,旧节点数据可恢复到新hash节点。

    2. rediscluster3.0自带的集群,特点在于他的分布式算法不是一致性hash,而是hash槽的概念,以及自身支持节点设置从节点。具体看官方文档介绍。

    3. 在业务代码层实现,起几个毫无关联的redis实例,在代码层,对key进行hash计算,然后去对应的redis实例操作数据。这种方式对hash层代码要求比较高,考虑部分包括,节点失效后的替代算法方案,数据震荡后的自动脚本恢复,实例的监控,等等。

    26、Redis集群方案什么情况下会导致整个集群不可用?

    有A,B,C三个节点的集群,在没有复制模型的情况下,如果节点B失败了,那么整个集群就会以为缺少5501-11000这个范围的槽而不可用。

    27、MySQL里有2000w数据,redis中只存20w的数据,如何保证redis中的数据都是热点数据?

    redis内存数据集大小上升到一定大小的时候,就会施行数据淘汰策略。

    28、Redis有哪些适合的场景?

    1. 会话缓存(SessionCache)
      最常用的一种使用Redis的情景是会话缓存(sessioncache)。用Redis缓存会话比其他存储(如Memcached)的优势在于:Redis提供持久化。当维护一个不是严格要求一致性的缓存时,如果用户的购物车信息全部丢失,大部分人都会不高兴的,现在,他们还会这样吗?

    幸运的是,随着Redis这些年的改进,很容易找到怎么恰当的使用Redis来缓存会话的文档。甚至广为人知的商业平台Magento也提供Redis的插件。

    1. 全页缓存(FPC)
      除基本的会话token之外,Redis还提供很简便的FPC平台。回到一致性问题,即使重启了Redis实例,因为有磁盘的持久化,用户也不会看到页面加载速度的下降,这是一个极大改进,类似PHP本地FPC。

    再次以Magento为例,Magento提供一个插件来使用Redis作为全页缓存后端。
    此外,对WordPress的用户来说,Pantheon有一个非常好的插件wp-redis,这个插件能帮助你以最快速度加载你曾浏览过的页面。

    1. 队列
      Reids在内存存储引擎领域的一大优点是提供list和set操作,这使得Redis能作为一个很好的消息队列平台来使用。Redis作为队列使用的操作,就类似于本地程序语言(如Python)对list的push/pop操作。

    如果你快速的在Google中搜索"Redisqueues",你马上就能找到大量的开源项目,这些项目的目的就是利用Redis创建非常好的后端工具,以满足各种队列需求。例如,Celery有一个后台就是使用Redis作为broker,你可以从这里去查看。

    1. 排行榜/计数器
      Redis在内存中对数字进行递增或递减的操作实现的非常好。集合(Set)和有序集合(SortedSet)也使得我们在执行这些操作的时候变的非常简单,Redis只是正好提供了这两种数据结构。所以,我们要从排序集合中获取到排名最靠前的10个用户-我们称之为“user_scores”,我们只需要像下面一样执行即可:

    当然,这是假定你是根据你用户的分数做递增的排序。如果你想返回用户及用户的分数,你需要这样执行:
    ZRANGEuser_scores010WITHSCORES
    AgoraGames就是一个很好的例子,用Ruby实现的,它的排行榜就是使用Redis来存储数据的,你可以在这里看到。

    1. 发布/订阅
      最后(但肯定不是最不重要的)是Redis的发布/订阅功能。发布/订阅的使用场景确实非常多。我已看见人们在社交网络连接中使用,还可作为基于发布/订阅的脚本触发器,甚至用Redis的发布/订阅功能来建立聊天系统!

    29、Redis支持的Java客户端都有哪些?官方推荐用哪个?

    Redisson、Jedis、lettuce等等,官方推荐使用Redisson。

    30、Redis和Redisson有什么关系?

    Redisson是一个高级的分布式协调Redis客服端,能帮助用户在分布式环境中轻松实现一些Java的对象(Bloomfilter,BitSet,Set,SetMultimap,ScoredSortedSet,SortedSet,Map,ConcurrentMap,List,ListMultimap,Queue,BlockingQueue,Deque,BlockingDeque,Semaphore,Lock,ReadWriteLock,AtomicLong,CountDownLatch,Publish/Subscribe,HyperLogLog)。

    31、Jedis与Redisson对比有什么优缺点?

    Jedis是Redis的Java实现的客户端,其API提供了比较全面的Redis命令的支持;
    Redisson实现了分布式和可扩展的Java数据结构,和Jedis相比,功能较为简单,不支持字符串操作,不支持排序、事务、管道、分区等Redis特性。Redisson的宗旨是促进使用者对Redis的关注分离,从而让使用者能够将精力更集中地放在处理业务逻辑上。

    32、Redis如何设置密码及验证密码?

    设置密码:config set require pass 123456 授权密码:auth123456

    33、说说Redis哈希槽的概念?

    Redis集群没有使用一致性hash,而是引入了哈希槽的概念,Redis集群有16384个哈希槽,每个key通过CRC16校验后对16384取模来决定放置哪个槽,集群的每个节点负责一部分hash槽。

    34、Redis集群的主从复制模型是怎样的?

    为了使在部分节点失败或者大部分节点无法通信的情况下集群仍然可用,所以集群使用了主从复制模型,每个节点都会有N-1个复制品.

    35、Redis集群会有写操作丢失吗?为什么?

    Redis并不能保证数据的强一致性,这意味这在实际中集群在特定的条件下可能会丢失写操作。

    36、Redis集群之间是如何复制的?

    异步复制

    37、Redis集群最大节点个数是多少?

    16384个。

    38、Redis集群如何选择数据库?

    Redis集群目前无法做数据库选择,默认在0数据库。

    39、怎么测试Redis的连通性?

    ping

    40、Redis中的管道有什么用?

    一次请求/响应服务器能实现处理新的请求即使旧的请求还未被响应。这样就可以将多个命令发送到服务器,而不用等待回复,最后在一个步骤中读取该答复。

    这就是管道(pipelining),是一种几十年来广泛使用的技术。例如许多POP3协议已经实现支持这个功能,大大加快了从服务器下载新邮件的过程。

    41、怎么理解Redis事务?

    事务是一个单独的隔离操作:事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中,不会被其他客户端发送来的命令请求所打断。事务是一个原子操作:事务中的命令要么全部被执行,要么全部都不执行。

    42、Redis事务相关的命令有哪几个?

    MULTI、EXEC、DISCARD、WATCH

    43、Rediskey的过期时间和永久有效分别怎么设置?

    EXPIRE和PERSIST命令。

    44、Redis如何做内存优化?

    尽可能使用散列表(hashes),散列表(是说散列表里面存储的数少)使用的内存非常小,所以你应该尽可能的将你的数据模型抽象到一个散列表里面。比如你的web系统中有一个用户对象,不要为这个用户的名称,姓氏,邮箱,密码设置单独的key,而是应该把这个用户的所有信息存储到一张散列表里面。

    45、Redis回收进程如何工作的?

    一个客户端运行了新的命令,添加了新的数据。
    Redi检查内存使用情况,如果大于maxmemory的限制,则根据设定好的策略进行回收。一个新的命令被执行,等等。

    所以我们不断地穿越内存限制的边界,通过不断达到边界然后不断地回收回到边界以下。

    如果一个命令的结果导致大量内存被使用(例如很大的集合的交集保存到一个新的键),不用多久内存限制就会被这个内存使用量超越。

    展开全文
  • Spring Boot缓存实战 Redis 设置有效时间自动刷新缓存-2 Spring Boot缓存实战 Caffeine 问题描述: 通过使用redis和Caffeine来做缓存,我们会发现一些问题。 如果只使用redis来做缓存我们会有大量的请求到redis...
  • Redis缓存同步

    千次阅读 2017-07-29 21:23:10
    当后台修改内容信息后(也就数据库信息发生修改时),只需要把redis缓存的数据删除即可。后台系统不直接操作redis数据库。 可以发布一个服务,当后台对内容信息修改后,调用服务即可。服务的功能就是根据cid删除...
  • 一级缓存 Mybatis一级缓存作用域是session,session commit之后缓存就失效了 二级缓存 Mybatis二级缓存作用域是sessionfactory,该缓存是以namespace为单位的(也就是一个Mapper.xml文件),不同namespace下的操作...
  • redis缓存和本地缓存混用是一种非常实用的实践方式。 优点:极大地降低了redis的读写频率,特别是处理特别耗时的业务逻辑(大于1分钟)。 缺点:会产生一定的延时,这个延时具体的影响将会根据业务的差别而定。...
  • Redis 水平扩展 困难 简单 可靠/易用 没有过期,内存淘汰等 可靠 访问速度 直接操作变量,延迟低 需要网络传输序列化 能否保存引用类型 可以保存引用类型 只能存字符串 进程内缓存缺点 1. 不利于水平...
  • 缓存-redis 三种模式搭建运行原理

    千次阅读 2018-10-15 10:11:10
    redis 缓存 主从 哨兵 集群
  • 缓存-redis持久化机制(RDBAOF)

    千次阅读 多人点赞 2021-07-17 11:32:18
    文章目录前言一、Redis中RDBAOF两种持久化机制概要介绍二、RDB(Redis DataBase)机制详解1.手动触发-save2.手动触发-bgsave3.自动触发-bgsave4.RDB 的优点5.RDB 的缺点三、AOF(Append Only File)机制详解1.持久化...
  • 多级缓存架构在行情系统中的应用
  • redis缓存同步策略 介绍 当信息分散在各个数据提供者之间时,记录系统是权威的数据源。 引入缓存解决方案时 ,我们会自动复制数据。 为避免不一致的读取数据完整性问题,同步数据库缓存(无论何时对系统进行...
  • redis同步缓存到mysql中

    千次阅读 2019-02-26 10:24:22
    需求:当数据库中修改添加或者删除时需要同步更新redis缓存。 分析:1.第一步应该是将所有mysql中的数据缓存同步到redis  2.当mysql数据全部同步到redis中说明redis中数据mysql中完全一致。  3.因为mysql中...
  • java web项目用redis实现oracle缓存,实现思路是怎样的,怎样保持oracle和redis同步
  • redis缓存和mysql数据库同步

    千次阅读 2018-01-29 13:56:21
    redis缓存和mysql数据库同步 解决方案 一、对强一致要求比较高的,应采用实时同步方案,即查询缓存查询不到再从DB查询,保存到缓存;更新缓存时,先更新数据库,再将缓存的设置过期(建议不要去更新缓存内容,直接...
  • 缓存_Redis_Redis配置参数

    千次阅读 2016-10-14 19:17:08
    一:简介(来自百科) redis是一个key-value存储系统。Memcached类似,它支持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)zset(有序集合)。这些数据类型都支持push
  • redis缓存同步方案

    千次阅读 2018-03-12 11:52:32
    持久层数据库和redis数据库同步方案,目前据我所知大都是通过自己写代码实现同步同步方案有如下几种:方案一:通过canal+mysql实现同步,关于canal之前有说过,该方案的好处:实现了数据同步的代码业务代码分离,...
  • REDIS缓存

    千次阅读 2018-08-31 16:25:24
    Redis缓存概述 Redis是一个开源的、使用C语言编写的、支持网络交互的、可基于内存也可持久化的key-value形式存储系统,它可以用作数据库、缓存消息中间件。Redis内置了复制(replication)、LUA脚本、LRU事件驱动...
  • redis缓存如何同步数据库

    千次阅读 2020-09-21 15:53:36
    redis缓存如何同步数据库 redis-mysql模式 读:服务程序先从缓存中读取数据,如果命中,则将数据读出。如果未命中,则在数据库中读取数据, 然后将数据写入到缓存中去。 更新数据:常见的模式是先到数据库中写入,...
  • redis 同步更新缓存数据

    千次阅读 2019-02-11 11:47:26
    问题场景 练习项目写后台的时候,在后台对前端...出现问题:实际数据更新,redis缓存中数据未更新 解决思路 在实际更新数据库操作的同时,对 redis 的缓存数据进行更新处理 具体步骤:删除原有的 redis 中的缓存...
  • 一、Redis 内存数据库简介 Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache and message broker. It supports data structures such as strings, hashes, ...
  • Guava缓存Redis

    千次阅读 2019-05-20 16:03:02
    https://www.jianshu.com/p/b3c10fcdbf0f
  • Redis缓存同步策略

    千次阅读 2018-03-19 18:28:08
    对数据库进行增删改时,将缓存中的数据进行删除,下次查询数据时会将查询的数据添加到缓存中去注意:删的时候尽量精确的删
  • Mybatis的一级缓存存放在SqlSession的生命周期,在同一个SqlSession中查询时,Mybatis会把执行的方法参数通过算法生成缓存的键值,将键值查询结果存入一个Map对象中。 如果同一个SqlSession中执行的方法参数...
  • 缓存技术Redis在C#中的使用及Redis的封装

    万次阅读 多人点赞 2015-07-06 10:48:05
    Redis的键值可以包括字符串(strings)、哈希(hashes)、列表(lists)、集合(sets) 有序集合(sorted sets)等数据类型。 对于这些数据类型,你可以执行原子操作。例如:对字符串进行附加操作(append);递增...
  • 本地缓存同步的一个简单方案

    千次阅读 2019-10-11 16:46:48
    现在大部分系统使用的都是分布式缓存系统Redis。 但在一些场景下,比如缓存单元很大,单元数不多,变化很小,加载时间很长,...本文介绍了一个简单的实现集群中同步各服务器本地缓存的方案。 实现思路: 集群各个...
  • 关于Redis的安装本篇不作介绍Redis主要用于缓存(数据查询,短连接,商品内容等),应用排行榜,访问统计等.. Redis常用数据类型 Redis最为常用的数据类型主要有以下五种:String Hash List Set Sorted setRedis配置...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 93,935
精华内容 37,574
关键字:

本地缓存和redis缓存同步

redis 订阅