缓存&分布式锁&SpringCache

自定义注解缓存feign结果 一、背景 在springcloud微服务架构中,可能会经常通过 feign 组件调用其它的微服务,feign的底层其实是模拟一个http请求,通过访问接口的方式调用远程服务,要经历三次握手建立TCP连接,在项目中是一个比较“耗时”的操作。 如果经常请求一些很少变动的数据,或者在一定时间段内可容忍已过期的数据,那么则需要在调用feign之前能不能从缓存中获取,可以自定义注解,将feign返回的结果缓存到redis中一段时间。 二、自定义注解 项目中需要使用:redis,aspect 1 - 定义一个注解标 阅读详情

一、缓存

1、缓存使用

为了系统性能的提升,我们一般都会将部分数据放入缓存中,加速访问。而 db 承担数据落盘工作

哪些数据适合放入缓存?

1)即时性、数据一致性要求不高的

2)访问量大且更新频率不高的数据(读多,写少)

举例:电商类应用,商品分类,商品列表等适合缓存并加一个失效时间(根据数据更新频率来定),后台如果发布一个商品,买家需要 5 分钟才能看到新的商品一般还是可以接受的。

在这里插入图片描述

伪代码:

data = cache.load(id);//从缓存加载数据
If(data == null){
    data = db.load(id);//从数据库加载数据
    cache.put(id,data);//保存到 cache 中
}
return data;

注意:在开发中,凡是放入缓存中的数据我们都应该指定过期时间,使其可以在系统即使没有主动更新数据也能自动触发数据加载进缓存的流程。避免业务崩溃导致的数据永久不一致问题。

二、整合redis作为缓存

1、引入redis-starter

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

2、配置文件中配置redis

spring:
  redis:
	host: 192.168.56.10
	port: 6379

3、使用redisTemplate操作redis

	@Autowired
	StringRedisTemplate stringRedisTemplate;

	@Test
	public void testStringRedisTemplate(){
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
        ops.set("hello","world_"+ UUID.randomUUID().toString());
        String hello = ops.get("hello");
        System.out.println(hello);
}

三、缓存失效问题

1、缓存穿透

​ 1、缓存穿透是指查询一个一定不存在的数据,由于缓存是不命中,将去查询数据库,但是数据库也无此记录,我们没有将这次查询的 null 写入缓存,这将导致这个不存在的数据每次请求都要到存储层去查询,失去了缓存的意义

​ 2、在流量大时,可能 DB 就挂掉了,要是有人利用不存在的 key 频繁攻击我们的应用,这就是漏洞

缓存穿透示意图:
在这里插入图片描述

缓存穿透是指查询一个根本不存在的数据,缓存层和持久层都不会命中,虽然对redis缓存服务器不会造成影响,但是数据库的负载就会增大,使得缓存的作用降低。

3、 解决方案:

​ 缓存空结果,并且设置过期时间

​ 缓存空对象:是指在持久层没有命中的情况下,对key进行set (key,null)

​ 缓存空对象会有两个问题:

第一,value为null 不代表不占用内存空间,空值做了缓存,意味着缓存层中存了更多的键,需要更多的内存空间,比较有效的方法是针对这类数据设置一个较短的过期时间,让其自动剔除。

第二,缓存层和存储层的数据会有一段时间的不一致,可能会对业务有一定影响。例如过期时间设置为5分钟,如果此时存储层添加了这个数据,那此段时间就会出现缓存层和存储层数据的不一致,此时可以利用消息系统或者其他方式清除掉缓存层中的空对象

2、缓存雪崩(大面积同时失效)

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

​ 2、解决方案:

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

3、缓存击穿

1、 对于一些设置了过期时间的 key,如果这些 key 可能会在某些时间点被超高并发地访问, 是一种非常“热点”的数据。

​ 2、 这个时候,需要考虑一个问题:如果这个 key 在大量请求同时进来前正好失效,那么所有对这个 key 的数据查询都落到 db,我们称为缓存击穿。

​ 3、解决方案:

​ 加锁

4、使用synchronized加锁,在分布式的情况下存在的问题

假如有8台机器,使用synchronized加锁,只能锁住一台机器,有8台机器,第一台机器把10000次请求锁住了,只放一个进来,第二台机器也是同样,把10000次的请求锁住,只放一个请求进来,其他机器都一样。 就会有8次请求放进来查询数据库查询相同的数据,那么有几台机器就会有几个线程进来。还是没有解决以上的问题,因为synchronized只能锁住各自服务。

在分布式的情况下,必须使用分布式锁来解决

在这里插入图片描述

四、分布式锁

1、分布式锁的概念

​ 分布式锁是指分布式环境下,系统部署在多个机器中,实现多进程分布式互斥的一种锁。为了保证多个进程能看到锁,锁被存在公共存储(比如 Redis、数据库等三方存储中),以实现多个进程并发访问同一个临界资源,同一时刻只有一个进程可访问共享资源,确保数据的一致性。

本地锁在分布式系统中存在的问题:

​ 当系统部署在多个机器中时

​ 请求方式:就是从单进程多线程的情况下变为多进程的环境

​ 如果还是使用本地锁,只能锁住当前进程,所以需要分布式锁

在这里插入图片描述

2、分布式锁的实现方式

​ 分布式锁就是所有的线程到同一个地方占锁[set一把锁],如果可以set进去,说明占锁成功(获取锁成功),则可以进行下一步的业务逻辑处理。执行完业务后再删除锁.

3、分布式锁的几个阶段演变过程
1、分布式锁 阶段一

在这里插入图片描述

2、分布式锁 - 阶段二

在这里插入图片描述

阶段二存在的问题,在占锁之后和设置锁的过期时间之前这个时间段出现系统异常(例如:突然断电…)等意外情况时,导致设置锁的过期时间这段代码没有执行,那么这个锁就永远存在,还是没有解决上面的死锁的问题。所有设置过期时间和占位必须是原子性的

代码:
在这里插入图片描述
设置占锁和设置锁的过期时间可以使用一条命令搞定

set lock[锁名称] 111 EX 300【锁过期时间】 NX

以上问题解决的思路是,设置锁的过期时间必须和加锁是同步的,原子的

/**
* 在占坑的同时,设置过期时间,是为了防止死锁的问题,添加过期时间和加锁必须是原子性的
*/
Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid,300,TimeUnit.SECONDS);
3、分布式锁 阶段三

在这里插入图片描述

阶段三存在以下两个问题

1)业务超时怎么处理?

2)自己执行的业务时间大于锁的过期时间,在执行业务的时候,自己的锁过期后自动删除了,等业务执行完成后,有可能把别人正在持有的锁删除了。如何保证删除的不是别人的锁?

获取值对比 + 对比成功删除 = 原子操作
4、分布式锁 阶段四

在这里插入图片描述

5、分布式锁 阶段五

在这里插入图片描述

使用脚本来解决 “获取值对比 + 对比成功删除 = 原子操作”

在这里插入图片描述

分布式锁的核心:加锁【占锁 + 设置过期时间】必须是原子性

​ 删除锁【获取值对比 + 对比成功删除】必须是原子性

核心代码:

/**
 * 添加分布式锁
 * @return
 */
public Map<String, List<Catelog2Vo>> getCategorysFromDbWithRedisLock() {
    String uuid = UUID.randomUUID().toString();
    /**
     * 在占坑的同时,设置过期时间,是为了防止死锁的问题,添加过期时间和加锁必须是原子性的
     */
    Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid,300,TimeUnit.SECONDS);
    if(lock){
        log.info("获取分布式锁成功.....");
        // 加锁成功......执行业务
        /**
             * 如果在此处设置锁的过期时间,当程序在占坑的时候出现异常,或者突然断电的极端情况,
             * 程序无法执行到此处,则该锁永远不会过期,就会出现死锁的情况
             * **********所有添加过期时间和加锁的过程必须是原子性的*********
             */
        // redisTemplate.expire("lock",30,TimeUnit.SECONDS);
        Map<String, List<Catelog2Vo>> cateoryData;
        try {
            cateoryData = getCateoryDataFromDb();
            /**
                 * 删除自己的锁
                 * 获取值对比+ 对比成功删除=原子操作
                 */
            /*String lockValue = redisTemplate.opsForValue().get("uuid");
                if(uuid.equals(lockValue)){
                    redisTemplate.delete("lock");
                }*/
        } finally {
            /**
                 * redis的Lua脚本原子解锁
                 */
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            Long lock1 = redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList("lock"), uuid);
        }
        return cateoryData;
    }else{
        // 加锁失败.......   自旋重试
        log.info("获取分布式锁失败,等待重试...");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return getCategorysFromDbWithRedisLock();
    }
}

五、Redisson完成分布式锁

1、简介

Redisson 是架设在 Redis 基础上的一个 Java 驻内存数据网格(In-Memory Data Grid)。充分的利用了 Redis 键值数据库提供的一系列优势,基于 Java 实用工具包中常用接口,为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力,大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务,更进一步简化了分布式环境中程序相互之间的协作。

2、使用方法

​ 1)配置redisson

@Configuration
public class MyRedissonConfig {

    /**
     * 所有对redisson的使用都是通过redissonClient对象
     * @return
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.18.38:6379");
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }
}

​ 2)使用分布式锁

	@Autowired
    private StringRedisTemplate redisTemplate;

	@Autowired
    private RedissonClient redissonClient;

	/**
     * 使用Redisson实现分布式锁
     * 缓存中的数据如何和数据库保持一致
     * @return
     */
    public Map<String, List<Catelog2Vo>> getCategorysFromDbWithRedissonLock() {
        // 1、占分布式锁,去redis占坑,锁的名字必须区分
        RLock lock = redissonClient.getLock("catalogJson-lock");
        lock.lock();
        log.info("获取分布式锁成功.....");

        Map<String, List<Catelog2Vo>> cateoryData;
        try {
            // 2、执行业务代码
            cateoryData = getCateoryDataFromDb();
        } finally {
            // 3、释放锁
            lock.unlock();
        }
        return cateoryData;
    }

--------------------------------------------------------------------------------------------
private Map<String, List<Catelog2Vo>> getCateoryDataFromDb() {
       // 查询redis缓存,如果缓存中存在,则直接返回,否则,执行下面查询数据库的操作
        String categoryJson = redisTemplate.opsForValue().get("categoryJson");
        if(!StringUtils.isEmpty(categoryJson)){
            Map<String, List<Catelog2Vo>> result = JSON.parseObject(categoryJson, new TypeReference<Map<String, List<Catelog2Vo>>>() {
            });
            return result;
        }

        List<CategoryEntity> categoryEntityList = baseMapper.selectList(null);
        log.info("查询了数据库.....");

        //查询出一级分类
        List<CategoryEntity> level1Categorys = getParent_cid(categoryEntityList,0L);
        // 封装数据
        Map<String, List<Catelog2Vo>> collect = level1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
            // 1、每一个的一级分类,查到这个一级分类的二级分类
            List<CategoryEntity> catLevel2 = getParent_cid(categoryEntityList,v.getCatId());
            List<Catelog2Vo> catelog2 = null;
            if (catLevel2 != null && !catLevel2.isEmpty()) {
                catelog2 = catLevel2.stream().map(l2 -> {
                    Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
                    // 2、查询当前二级分类的三级分类封装成vo
                    List<CategoryEntity> catLevel3 = getParent_cid(categoryEntityList,l2.getCatId());
                    if(catLevel3 != null && !catLevel3.isEmpty()){
                        List<Catelog2Vo.Catelog3Vo> catelog3Vos = catLevel3.stream().map(l3 -> {
                            Catelog2Vo.Catelog3Vo catelog3Vo = new Catelog2Vo.Catelog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
                            return catelog3Vo;
                        }).collect(Collectors.toList());
                        catelog2Vo.setCatalog3List(catelog3Vos);
                    }
                    return catelog2Vo;
                }).collect(Collectors.toList());
            }
            return catelog2;
        }));
        String s = JSONObject.toJSONString(collect);
        // 将查询到的数据放入缓存中 设置过期时间为1天
        redisTemplate.opsForValue().set("categoryJson",s,1, TimeUnit.DAYS);
        return collect;
    }

六、SpringCache实现缓存

1、整合springCache简化缓存开发

​ 1)引入依赖

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

<!--引入redis-->
        <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>

2)配置

(1)自动配置了哪些?

​ CacheAutoConfiguration会导入RedisCacheConfiguration,自动配置好了缓存管理器RedisCacheManager

**配置使用redis作为缓存,在application.properties中配置**
 spring.cache.type=redis

3)开启缓存功能,在主启动类中使用@EnableCaching注解开启使用缓存

@EnableCaching
@EnableFeignClients(basePackages = "com.atguigu.gulimall.product.feign")
@MapperScan("com.atguigu.gulimall.product.dao")
@SpringBootApplication
@EnableDiscoveryClient
public class GulimallProductApplication {

    public static void main(String[] args) {
        SpringApplication.run(GulimallProductApplication.class, args);
    }

}
2、几个重要的注解
1、@Cacheable

​ @Cacheable注解:使用在当前方法的结果需要缓存,如果缓存中有,方法就不用调用。如果缓存中没有,会调用方法,最后将方法的结果放入缓存中。【这个注解一般用在查询方法上】

/**
 * 每个需要缓存的数据我们都来指定要放到那个名字的缓存【缓存分区(按照业务类型分)】
 * @return
 */
@Cacheable({"category"})
@Override
public List<CategoryEntity> getLevel1Categorys() {
    long startTime = System.currentTimeMillis();
    List<CategoryEntity> entities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("cat_level", 1));
    System.out.println("查询一级菜单消耗的时间:{}" + (System.currentTimeMillis() - startTime));
    return entities;
}

添加了@Cacheable注解后,调用接口,第一次会查询数据库,将结果存入到缓存中,第二次…就直接在缓存中取数据啦。@Cacheable默认行为:(1)如果缓存中有,方法不用调用(2)key默认自动生成:缓存的名字::SimpleKey[] (自动生成的key值)(3)缓存的value的值,默认使用jdk序列化机制,将序列化后的数据存入到redis (4) 默认ttl时间(过期时间):-1(永不过期)

2、@CachePut

加了@CachePut注解的方法,会把方法的返回值put到缓存里面缓存起来,供其它地方使用。它**「通常用在新增方法上」。
**

3、@CacheEvict

使用了CacheEvict注解的方法,会清空指定缓存。「一般用在更新或者删除的方法上」。

4、@Caching

组合以上多个操作

5、@CacheConfig

在类级别共享缓存的相同配置

springboot2.0 redis使用lettuce连接包实现分布式锁关键词setnx springboot升级到2.0之后,关联的spring-data-redis默认使用的连接包也从原本的jedis改为了性能更好,且线程安全的使用netty实现的lettuce连接包。 鉴于spring-data默认只提供了setnx不带过期时间的入口,为了防止分布式锁的死锁只能自己来实现setnx关键词 以下是使用默认的stringRedisTemplate实现setnx的过程: /**... 阅读详情

相关推荐

从模组到集装箱:手把手拆解一个储能BMS的软硬件架构设计与通信组网

本文深入解析储能BMS的软硬件架构设计与通信组网,从电芯采样到系统集成的全链条技术实现。详细介绍了三级硬件架构(AFE、CMU、BMU)的设计要点,以及软件分层实现中的驱动层、应用层核心算法和通信协议栈。通过实战案例分享CAN网络搭建、调试工具链和系统验证测试经验,为储能系统开发提供实用指导。

weixin_30752699的博客 465

踩坑记录---openFeign高并发阻塞分析与解决

openFeign在高并发状态下发现阻塞与分析, 公司某业务需要使用http协议去大量调用三方推送服务,因项目本身为Spring Cloud 服务,切通信框架为 OpenFeign,所以调用三方服务时,使用的是 OpenFeign。

编码爱好者 5122

AT32串口打印全攻略:从零搭建到printf重定向(GCC版)

本文详细介绍了在GCC编译环境下为AT32系列MCU实现串口打印与printf重定向的完整方案。针对从Keil MDK迁移到GCC工具链时常见的串口无输出问题,文章从环境搭建、USART配置入手,重点剖析了GCC下printf重定向的核心原理——通过重写_write()函数,并提供了经过验证的代码实现、常见问题排查及性能优化建议。

weixin_29163797的博客 266

教你怎么用分布式锁解决并发问题?

在系统中,当存在多个进程和线程可以改变某个共享数据时,就容易出现并发问题导致共享数据的不一致性。即多个进程同时获取到了对数据的操作权限并对数据进行了更新,很典型的场景就是在线销售系统在售卖热销商品时遇到多个并发请求在同一时间提交订单的情况则极有可能造成商品超卖的现象。只要访问流量不错的系统都有可能遭遇并发请求造成数据库中数据重复写入的情况。 针对程序块被多个进程并发执行问题的解决方案是...

qq_39662660的博客 1034

华为防火墙USG6600全流量日志配置指南:从流量监控到NAT日志的完整方案

本文详细介绍了华为USG6600防火墙全流量日志配置方案,涵盖流量监控、NAT日志及安全事件溯源等核心功能。通过精细化配置和性能优化技巧,帮助企业构建高效、合规的日志体系,提升网络安全运维效率。文章特别强调了日志采样与字段过滤的实用方法,适用于高流量环境下的资源优化。

gin88的博客 350

用Charles抓包调试iOS应用?这份保姆级配置指南帮你绕过所有坑

本文提供了一份在Mac上使用Charles抓包调试iOS应用的保姆级配置指南。详细讲解了从Charles安装、Mac端代理设置、根证书安装,到iOS设备连接同一WiFi、配置代理以及最关键的系统证书信任等全流程步骤,并分享了SSL代理规则、断点调试等进阶技巧,帮助开发者高效定位和解决网络请求问题。

rice5的博客 641

分布式缓存Spring Cache

1、 Spring 从 3.1 开始定义了org.springframework.cache.Cache和 org.springframework.cache.CacheManager 接口来统一不同的缓存技术;并支持使用 JCache(JSR-107)注解简化我们开发;2、Cache 接口为缓存的组件规范定义,包含缓存的各种操作集合;Cache 接 口 下 Spring 提 供 了 各 种 xxxCache 的 实 现;

weixin_46258873的博客 619

相机标定原理与张氏标定法

这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar

heeweii的博客 2281

分布式缓存架构基础

一、缓存概述 1.1 什么是缓存      缓存在wiki上的定义:用于存储数据的硬件或软件的组成部分,以使得后续更快访问相应的数据。缓存中的数据可能是提前计算好的结果、数据的副本等。典型的应用场景:有cpu cache, 磁盘cache等。本文中提及到缓存主要是指互联网应用中所使用的缓存组件。 1.2 为什么引入缓存     传统的后端业务场景中,访问量以及对响应时间的要求均不高,通常只

lz0426001的专栏 1万+

Ubuntu 22.04/24.04 安装 ROS2 完整教程(Humble / Jazzy)

最后更新:2026年2月适用系统:Ubuntu 22.04 LTS(Jammy) / Ubuntu 24.04 LTS(Noble)适用架构:x86_64 / arm64(包括树莓派)

2401_84116277的博客 6041

点云从入门到精通技术详解100篇-基于 CBCT 与口内扫描数据的牙齿点云配准

口扫生成的三维牙模型只包含牙冠结构,容易受到唾液、食物残留等杂质的干扰。像精度,但其扫描成本较高,在公立医院的普及率较低。此外,口扫探入式的体。完整、精确的牙齿信息,有助于医生更好地进行数字化辅助诊疗,提高手术的预。可以表示上颌骨、下颌骨、牙冠以及牙根的位置和形状,但其扫描分辨率较低,精配准前实现粗略的预配准来确定点云间的初始位置,为精配准提供良好的配准。该算法通过计算点对间的距离确定源点云中的某一点在目标点云中的对应。算两点之间的欧氏距离,运算量较大,而且由于算法只考虑点集间的距离而忽略。

getusushu的博客 1642

谷粒商城-缓存使用&分布式锁&SpringCache(5天)

• 我们能放入缓存的数据本就不应该是实时性、一致性要求超高的。所以缓存数据的时候加上过期时间,保证每天拿到当前最新数据即可。• 我们不应该过度设计,增加系统的复杂性• 遇到实时性、一致性要求高的数据,就应该查数据库,即使慢点。/*** 需要将配置文件中的配置设置上* 1、使配置类生效* 1)开启配置类与属性绑定功能EnableConfigurationProperties* 2)注入就可以使用了。

weixin_44925329的博客 1482

eDP V1.4协议介绍

eDP的全称是Embedded DisplayPort嵌入式显示端口,主要应用与短距离系统内应用,例如手机、一体式台式机等。eDP V1.4b是基于DP V1.3标准制作完成,但因应用场景的不同,还是有很多区别。电压摆幅不同,eDP相对较低;eDP功耗相对较低;DP有线材和连接器的要求,eDP没有明确要求;AUX通道电路设计不同(相对DP取消了AC耦合电容和100KΩ/1MΩ的上下拉电阻):典型应用场景;

qflook的博客 4307

Java如何使用分布式缓存和分布式锁?

如何使用分布式缓存?一、引入1.1、哪些数据需要放入缓存二、如何使用缓存中间件Redis?如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 一、引入 为了使系统提升性能,我们一般会将部分数据放入缓存,加速系统业务的访问,而DB只承担数据的落盘工作 1.1、哪些数据需要放入

一个勤勤恳恳的程序猿 1461

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an &ldquo;advanced algorithms&rdquo; book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

分布事务和分布式锁

Saga是一个长活事务,可被分解成可以交错运行的子事务集合,每个子事务有相应的执行模块和补偿模块,当saga事务中的任意一个本地事务出错了,可以通过调用相关事务对应的补偿方法恢复,达到事务的最终一致性。二阶段提交协议(Two-phase Commit,即 2PC)是常用的分布式事务解决方案,即将事务的提交过程分为两个阶段来进行处理:准备阶段和提交阶段。三阶段提交协议,是二阶段提交协议的改进版本,与二阶段提交不同的是,引入超时机制。同时在协调者和参与者中都引入超时机制。...

潜行前行的专栏 878

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain&#39;s apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = &quot;R. B. Palm&quot;, title = &quot;Prediction as a candidate for learning deep hierarchical models of data&quot;, year = &quot;2012&quot;,}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath(&#39;DeepLearnToolbox&#39;));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand(&#39;state&#39;,0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W&#39;); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand(&#39;state&#39;,0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = &#39;sigm&#39;;%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.10, &#39;Too big error&#39;);```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand(&#39;state&#39;,0)sae = saesetup([784 100]);sae.ae{1}.activation_function = &#39;sigm&#39;;sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)&#39;)% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = &#39;sigm&#39;;nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.16, &#39;Too big error&#39;);```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x&#39;,28,28,60000))/255;test_x = double(reshape(test_x&#39;,28,28,10000))/255;train_y = double(train_y&#39;);test_y = double(test_y&#39;);%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you&#39;ll get around 1.2% errorrand(&#39;state&#39;,0)cnn.layers = { struct(&#39;type&#39;, &#39;i&#39;) %input layer struct(&#39;type&#39;, &#39;c&#39;, &#39;outputmaps&#39;, 6, &#39;kernelsize&#39;, 5) %convolution layer struct(&#39;type&#39;, &#39;s&#39;, &#39;scale&#39;, 2) %sub sampling layer struct(&#39;type&#39;, &#39;c&#39;, &#39;outputmaps&#39;, 12, &#39;kernelsize&#39;, 5) %convolution layer struct(&#39;type&#39;, &#39;s&#39;, &#39;scale&#39;, 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er&lt;0.12, &#39;Too big error&#39;);```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.08, &#39;Too big error&#39;);%% ex2 neural net with L2 weight decayrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.1, &#39;Too big error&#39;);%% ex3 neural net with dropoutrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.1, &#39;Too big error&#39;);%% ex4 neural net with sigmoid activation functionrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.activation_function = &#39;sigm&#39;; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.1, &#39;Too big error&#39;);%% ex5 plotting functionalityrand(&#39;state&#39;,0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = &#39;softmax&#39;; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.1, &#39;Too big error&#39;);%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand(&#39;state&#39;,0)nn = nnsetup([784 20 10]); nn.output = &#39;softmax&#39;; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.1, &#39;Too big error&#39;);```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free &quot;Bitdeli Badge&quot;)

Springboot-redis-springcache缓存-分布式锁redisson

redis

weixin_44748599的博客 1812

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

SpringCloud Feign重试详解

feign是netflix提供的服务间基于http的rpc调用框架,在spring cloud得到广泛应用。默认情况下,一个feign client是在hystrix断路器中执行,并利用ribbon进行软负载选择远程target service,所以可以想象出一个feign cli...

chuitingpi7963的博客 1254

谷粒商城8:分布式锁使用和springcache的整合

学习

qq_44724899的博客 1842

feign接口数据缓存

spring cloud微服务架构开发中,服务间通过feign调用,用的很爽,但有的时候一次业务逻辑操作需要调同一个接口很多次,接口返回的数据是一样的,多次rpc调用,网络开销很大,影响性能。 如果每次调用返回的数据是固定的,何不把它缓存起来呢? 这里我们直接用spring的缓存注解@Cacheable来做本地缓存。 一、定义一个...

weixin_37627058的博客 8734

SpringBoot2.3.4整合Redisson和SpringCache实现分布式锁和分布式缓存

概述 为了提升访问效率,适应高并发访问,在程序中引入了缓存,常见的缓存有本地缓存和分布式缓存,分布式缓存中常使用Redis中间件实现。在高并发下缓存会存在失效问题,常见的缓存失效有以下三种: 缓存穿透 查询一个一定不存在的数据,由于缓存是不命中,将去查询数据库,但是数据库也无此记录,我们没有将这次查询的null写入缓存,这将导致这个不存在的数据每次请求都要到存储层去查询,失去了缓存的意义 风险:利用不存在的数据进行攻击,数据库瞬时压力增大,最终导致崩溃 解决:null结果缓存,并加入短暂过期时间 缓存雪崩

liu320yj的博客 3328

缓存(redis)安装使用+分布式锁+springcache

1. 打开redis.windows.conf文件 找到requirepass 放开并修改值。导入到common模块中 其他模块报错了 我们就单独导入到我们需要使用的模块中即可。2.找到port 6379 并修改值即可。2.2配置密码端口等(可选)测试操作Redis的数据。

qq_31041167的博客 707

锁cache

锁cache操作 1:把要锁的内存地址放到锁cache寄存器A里 2:要锁内存大小放到寄存器B里 这样一段内存就被锁到cache里了 原理就是。当我取值访问内存,或者访问内存数据的时候,cache里将百分百命中,提高访问读写速度,我的所有对内存的读写都落到了cache里,永远不会修改到内存里的东西了,所有对内存的修改,都是直接修改cache的数据存储。 ...

qq_38350702的博客 849

Spring Boot使用Redisson分布式锁解决缓存击穿问题

文章目录1 什么是缓存击穿2 为什么要使用分布式锁3 什么是Redisson4 Spring Boot集成Redisson4.1 添加maven依赖4.2 配置yml4.3 配置RedissonConfig5 使用Redisson的分布式锁解决缓存击穿 1 什么是缓存击穿 一份热点数据,它的访问量非常大。在其缓存失效的瞬间,大量请求直达存储层,导致服务崩溃。 2 为什么要使用分布式锁 在项目中,当共享资源出现竞争情况的时候,为了防止出现并发问题,我们一般会采用锁机制来控制。在单机环境下,可以使用synchr

dreaming9420的博客 4114

使用Spring Cache优雅的实现分布式二级缓存!

大家好,我是不才陈某~在学习Spring Cache之前,大家经常会硬编码的方式使用缓存。我们来举个实际中的例子,为了提升用户信息的查询效率,我们对用户信息使用了缓存,示例代码如下:@Autowire privateUserMapperuserMapper; @Autowire privateRedisCacheredisCache; //查询用户 ...

码猿技术专栏 1137

Java大牛必会|分布式缓存实现方案之Spring Cache

可以在评论区给我留言哦。Spring Cache并非一种具体的缓存技术,而是基于各种缓存产品(如Guava、EhCache、Redis等)进行的一层封装,结合SpringBoot开箱即用的特性用起来会非常方便;Miss率 = 没有从缓存中读取的次数 / (总读取次数[从缓存中读取次数 + 从慢速设备上读取的次数])命中率 = 从缓存中读取次数 / (总读取次数[从缓存中读取次数 + 从慢速设备上读取的次数]);小白:杨哥,今天我做分布式缓存时,看到公司用了Spring Cache,这个技术你能给我讲讲吗?

威哥爱编程,华为 HDE,鸿蒙极客、优快云博客专家、《鸿蒙 HarmonyOS 5/6 开发之路》系列图书第一作者 2280

spring缓存@Cacheable死锁问题

@Cacheable注解引发异常问题

mjm_1251162714的博客 3357
上一篇: 本地事务&分布式事务
下一篇: ThreadLocal类
程序员老石
博客等级 码龄8年 286粉丝 162原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值