SpringBoot中使用Redis实现分布式锁

news2024/11/18 11:42:24

文章目录

      • 一。Redis实现分布式锁原理
      • 二。代码实现Redis分布式锁

一。Redis实现分布式锁原理

以下内容为转载部分，主要介绍Redis实现分布式锁的背景：
转载博客：https://blog.csdn.net/fuzhongmin05/article/details/119251590

为什么需要分布式锁

在聊分布式锁之前，有必要先解释一下，为什么需要分布式锁。

与分布式锁相对就的是单机锁，我们在写多线程程序时，避免同时操作一个共享变量产生数据问题，通常会使用一把锁来互斥以保证共享变量的正确性，其使用范围是在同一个进程中。如果换做是多个进程，需要同时操作一个共享资源，如何互斥呢？现在的业务应用通常是微服务架构，这也意味着一个应用会部署多个进程，多个进程如果需要修改MySQL中的同一行记录，为了避免操作乱序导致脏数据，此时就需要引入分布式锁了。
在这里插入图片描述

想要实现分布式锁，必须借助一个外部系统，所有进程都去这个系统上申请加锁。而这个外部系统，必须要实现互斥能力，即两个请求同时进来，只会给一个进程加锁成功，另一个失败。这个外部系统可以是数据库，也可以是Redis或Zookeeper，但为了追求性能，我们通常会选择使用Redis或Zookeeper来做。

Redis本身可以被多个客户端共享访问，正好就是一个共享存储系统，可以用来保存分布式锁。而且 Redis 的读写性能高，可以应对高并发的锁操作场景。本文主要探讨如何基于Redis实现分布式锁以及实现过程中可能面临的问题。

分布式锁如何实现

作为分布式锁实现过程中的共享存储系统，Redis可以使用键值对来保存锁变量，在接收和处理不同客户端发送的加锁和释放锁的操作请求。那么，键值对的键和值具体是怎么定的呢？我们要赋予锁变量一个变量名，把这个变量名作为键值对的键，而锁变量的值，则是键值对的值，这样一来，Redis就能保存锁变量了，客户端也就可以通过Redis的命令操作来实现锁操作。

想要实现分布式锁，必须要求Redis有互斥的能力。可以使用SETNX命令，其含义是SET IF NOT EXIST，即如果key不存在，才会设置它的值，否则什么也不做。两个客户端进程可以执行这个命令，达到互斥，就可以实现一个分布式锁。

以下展示了Redis使用key/value对保存锁变量，以及两个客户端同时请求加锁的操作过程。

在这里插入图片描述

加锁操作完成后，加锁成功的客户端，就可以去操作共享资源，例如，修改MySQL的某一行数据。操作完成后，还要及时释放锁，给后来者让出操作共享资源的机会。如何释放锁呢？直接使用DEL命令删除这个key即可。这个逻辑非常简单，整体的流程写成伪代码就是下面这样。

// 加锁
SETNX lock_key 1
// 业务逻辑
DO THINGS
// 释放锁
DEL lock_key

但是，以上实现存在一个很大的问题，当客户端1拿到锁后，如果发生下面的场景，就会造成死锁。

  1. 程序处理业务逻辑异常，没及时释放锁
  2. 进程挂了，没机会释放锁

以上情况会导致已经获得锁的客户端一直占用锁，其他客户端永远无法获取到锁。

如何避免死锁

为了解决以上死锁问题，最容易想到的方案是在申请锁时，在Redis中实现时，给锁设置一个过期时间，假设操作共享资源的时间不会超过10s，那么加锁时，给这个key设置10s过期即可。

但以上操作还是有问题，加锁、设置过期时间是2条命令，有可能只执行了第一条，第二条却执行失败，例如：

1.SETNX执行成功，执行EXPIRE时由于网络问题，执行失败
2.SETNX执行成功，Redis异常宕机，EXPIRE没有机会执行
3.SETNX执行成功，客户端异常崩溃，EXPIRE没有机会执行

总之这两条命令如果不能保证是原子操作，就有潜在的风险导致过期时间设置失败，依旧有可能发生死锁问题。幸好在Redis 2.6.12之后，Redis扩展了SET命令的参数，可以在SET的同时指定EXPIRE时间，这条操作是原子的，例如以下命令是设置锁的过期时间为10秒。

SET lock_key 1 EX 10 NX

至此，解决了死锁问题，但还是有其他问题。想像下面这个这样一种场景：
在这里插入图片描述

  1. 客户端1加锁成功，开始操作共享资源
  2. 客户端1操作共享资源耗时太久，超过了锁的过期时间，锁失效（锁被自动释放）
  3. 客户端2加锁成功，开始操作共享资源
  4. 客户端1操作共享资源完成，在finally块中手动释放锁，但此时它释放的是客户端2的锁。

这里存在两个严重的问题：

  • 锁过期
  • 释放了别人的锁

第1个问题是评估操作共享资源的时间不准确导致的，如果只是一味增大过期时间，只能缓解问题降低出现问题的概率，依旧无法彻底解决问题。原因在于客户端在拿到锁之后，在操作共享资源时，遇到的场景是很复杂的，既然是预估的时间，也只能是大致的计算，不可能覆盖所有导致耗时变长的场景。

第2个问题是释放了别人的锁，原因在于释放锁的操作是无脑操作，并没有检查这把锁的归属，这样解锁不严谨。如何解决呢？

锁被别人给释放了

解决办法是，客户端在加锁时，设置一个只有自己知道的唯一标识进去，例如可以是自己的线程ID，如果是redis实现，就是SET key unique_value EX 10 NX。之后在释放锁时，要先判断这把锁是否归自己持有，只有是自己的才能释放它。

//释放锁 比较unique_value是否相等，避免误释放
if redis.get("key") == unique_value then
    return redis.del("key")

这里释放锁使用的是GET + DEL两条命令，这时又会遇到原子性问题了。

  1. 客户端1执行GET，判断锁是自己的
  2. 客户端2执行了SET命令，强制获取到锁（虽然发生概念很低，但要严谨考虑锁的安全性）
  3. 客户端1执行DEL，却释放了客户端2的锁

由此可见，以上GET + DEL两个命令还是必须原子的执行才行。怎样原子执行两条命令呢？答案是Lua脚本，可以把以上逻辑写成Lua脚本，让Redis执行。因为Redis处理每个请求是单线程执行的，在执行一个Lua脚本时其它请求必须等待，直到这个Lua脚本处理完成，这样一来GET+DEL之间就不会有其他命令执行了。

以下是使用Lua脚本（unlock.script）实现的释放锁操作的伪代码，其中，KEYS[1]表示lock_key，ARGV[1]是当前客户端的唯一标识，这两个值都是我们在执行 Lua脚本时作为参数传入的。

//Lua脚本语言，释放锁 比较unique_value是否相等，避免误释放
if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

最后我们执行以下命令，即可

redis-cli  --eval  unlock.script lock_key , unique_value

这样一路优先下来，整个加锁、解锁流程就更严谨了，先小结一下，基于Redis实现的分布式锁，一个严谨的流程如下：

  1. 加锁时要设置过期时间SET lock_key unique_value EX expire_time NX
  2. 操作共享资源
  3. 释放锁：Lua脚本，先GET判断锁是否归属自己，再DEL释放锁

有了这个严谨的锁模型，我们还需要重新思考之前的那个问题，锁的过期时间不好评估怎么办。

如何确定锁的过期时间

前面提到过，过期时间如果评估得不好，这个锁就会有提前过期的风险，一种妥协的解决方案是，尽量冗余过期时间，降低锁提前过期的概率，但这个方案并不能完美解决问题。是否可以设置这样的方案，加锁时，先设置一个预估的过期时间，然后开启一个守护线程，定时去检测这个锁的失效时间，如果锁快要过期了，操作共享资源还未完成，那么就自动对锁进行续期，重新设置过期时间。

这是一种比较好的方案，已经有一个库把这些工作都封装好了，它就是Redisson。Redisson是一个Java语言实现的Redis SDK客户端，在使用分布式锁时，它就采用了自动续期的方案来避免锁过期，这个守护线程我们一般叫它看门狗线程。这个SDK提供的API非常友好，它可以像操作本地锁一样操作分布式锁。客户端一旦加锁成功，就会启动一个watch dog看门狗线程，它是一个后台线程，会每隔一段时间（这段时间的长度与设置的锁的过期时间有关）检查一下，如果检查时客户端还持有锁key（也就是说还在操作共享资源），那么就会延长锁key的生存时间。
在这里插入图片描述

那如果客户端在加锁成功后就宕机了呢？宕机了那么看门狗任务就不存在了，也就无法为锁续期了，锁到期自动失效。

Redis的部署方式对锁的影响

上面讨论的情况，都是锁在单个Redis 实例中可能产生的问题，并没有涉及到Redis的部署架构细节。

Redis发展到现在，几种常见的部署架构有：

  • 单机模式；
  • 主从模式；
  • 哨兵（sentinel）模式；
  • 集群模式；

我们使用Redis时，一般会采用主从集群+哨兵的模式部署，哨兵的作用就是监测redis节点的运行状态。普通的主从模式，当master崩溃时，需要手动切换让slave成为master，使用主从+哨兵结合的好处在于，当master异常宕机时，哨兵可以实现故障自动切换，把slave提升为新的master，继续提供服务，以此保证可用性。那么当主从发生切换时，分布式锁依旧安全吗？
在这里插入图片描述

想像这样的场景：

  1. 客户端1在master上执行SET命令，加锁成功
  2. 此时，master异常宕机，SET命令还未同步到slave上（主从复制是异步的）
  3. 哨兵将slave提升为新的master，但这个锁在新的master上丢失了，导致客户端2来加锁成功了，两个客户端共同操作共享资源

可见，当引入Redis副本后，分布式锁还是可能受到影响。即使Redis通过sentinel保证高可用，如果这个master节点由于某些原因发生了主从切换，那么就会出现锁丢失的情况。

集群模式+Redlock实现高可靠的分布式锁

为了避免Redis实例故障而导致的锁无法工作的问题，Redis的开发者 Antirez提出了分布式锁算法Redlock。Redlock算法的基本思路，是让客户端和多个独立的Redis实例依次请求加锁，如果客户端能够和半数以上的实例成功地完成加锁操作，那么我们就认为，客户端成功地获得分布式锁了，否则加锁失败。这样一来，即使有单个Redis实例发生故障，因为锁变量在其它实例上也有保存，所以，客户端仍然可以正常地进行锁操作，锁变量并不会丢失。

来具体看下Redlock算法的执行步骤。Redlock算法的实现要求Redis采用集群部署模式，无哨兵节点，需要有N个独立的Redis实例（官方推荐至少5个实例）。接下来，我们可以分成3步来完成加锁操作。
在这里插入图片描述

第一步是，客户端获取当前时间。
第二步是，客户端按顺序依次向N个Redis实例执行加锁操作。

这里的加锁操作和在单实例上执行的加锁操作一样，使用SET命令，带上NX、EX/PX选项，以及带上客户端的唯一标识。当然，如果某个Redis实例发生故障了，为了保证在这种情况下，Redlock算法能够继续运行，我们需要给加锁操作设置一个超时时间。如果客户端在和一个Redis实例请求加锁时，一直到超时都没有成功，那么此时，客户端会和下一个Redis实例继续请求加锁。加锁操作的超时时间需要远远地小于锁的有效时间，一般也就是设置为几十毫秒。

第三步是，一旦客户端完成了和所有Redis实例的加锁操作，客户端就要计算整个加锁过程的总耗时。

客户端只有在满足两个条件时，才能认为是加锁成功，条件一是客户端从超过半数（大于等于 N/2+1）的Redis实例上成功获取到了锁；条件二是客户端获取锁的总耗时没有超过锁的有效时间。

为什么大多数实例加锁成功才能算成功呢？多个Redis实例一起来用，其实就组成了一个分布式系统。在分布式系统中总会出现异常节点，所以在谈论分布式系统时，需要考虑异常节点达到多少个，也依旧不影响整个系统的正确运行。这是一个分布式系统的容错问题，这个问题的结论是：如果只存在故障节点，只要大多数节点正常，那么整个系统依旧可以提供正确服务。

在满足了这两个条件后，我们需要重新计算这把锁的有效时间，计算的结果是锁的最初有效时间减去客户端为获取锁的总耗时。如果锁的有效时间已经来不及完成共享数据的操作了，我们可以释放锁，以免出现还没完成共享资源操作，锁就过期了的情况。

当然，如果客户端在和所有实例执行完加锁操作后，没能同时满足这两个条件，那么，客户端就要向所有Redis节点发起释放锁的操作。为什么释放锁，要操作所有的节点呢，不能只操作那些加锁成功的节点吗？因为在某一个Redis节点加锁时，可能因为网络原因导致加锁失败，例如一个客户端在一个Redis实例上加锁成功，但在读取响应结果时由于网络问题导致读取失败，那这把锁其实已经在Redis上加锁成功了。所以释放锁时，不管之前有没有加锁成功，需要释放所有节点上的锁以保证清理节点上的残留的锁。

在Redlock算法中，释放锁的操作和在单实例上释放锁的操作一样，只要执行释放锁的 Lua脚本就可以了。这样一来，只要N个Redis实例中的半数以上实例能正常工作，就能保证分布式锁的正常工作了。所以，在实际的业务应用中，如果你想要提升分布式锁的可靠性，就可以通过Redlock算法来实现。

二。代码实现Redis分布式锁

1.SpringBoot整合redis用到最多的当然属于我们的老朋友RedisTemplate，pom依赖如下：

<!-- springboot整合redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.Redis配置类:

package com.example.redisdemo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @description: Redis配置类
 * @author Keson
 * @date 21:20 2022/11/14
 * @Param
 * @return
 * @version 1.0
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        // 设置序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        RedisSerializer<?> stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);// key序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);// value序列化
        redisTemplate.setHashKeySerializer(stringSerializer);// Hash key序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

3.Service层面

package com.example.redisdemo.service;

import com.example.redisdemo.entity.CustomerBalance;
import java.util.concurrent.Callable;

/**
 * @author Keson
 * @version 1.0
 * @description: TODO
 * @date 2022/11/14 15:12
 */
public interface RedisService {

    <T> T callWithLock(CustomerBalance customerBalance, Callable<T> callable) throws Exception;
}


package com.example.redisdemo.service.impl;

import com.example.redisdemo.entity.CustomerBalance;
import com.example.redisdemo.service.RedisService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.stereotype.Service;
import java.nio.charset.StandardCharsets;
import java.util.UUID;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

/**
 * @author Keson
 * @version 1.0
 * @description: TODO Redis实现分布式锁
 * @date 2022/11/14 15:13
 */
@Service
@Slf4j
public class RedisServiceImpl implements RedisService {

    //设置默认过期时间
    private final static int DEFAULT_LOCK_EXPIRY_TIME = 20;
    //自定义lock key前缀
    private final static String LOCK_PREFIX = "LOCK:CUSTOMER_BALANCE";

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public <T> T callWithLock(CustomerBalance customerBalance, Callable<T> callable) throws Exception{
        //自定义lock key
        String lockKey = getLockKey(customerBalance.getCustomerNumber(), customerBalance.getSubAccountNumber(), customerBalance.getCurrencyCode());
        //将UUID当做value，确保唯一性
        String lockReference = UUID.randomUUID().toString();

        try {
            if (!lock(lockKey, lockReference, DEFAULT_LOCK_EXPIRY_TIME, TimeUnit.SECONDS)) {
                throw new Exception("lock加锁失败");
            }
            return callable.call();
        } finally {
            unlock(lockKey, lockReference);
        }
    }

    //定义lock key
    String getLockKey(String customerNumber, String subAccountNumber, String currencyCode) {
        return String.format("%s:%s:%s:%s", LOCK_PREFIX, customerNumber, subAccountNumber, currencyCode);
    }

    //redis加锁
    private boolean lock(String key, String value, long timeout, TimeUnit timeUnit) {
        Boolean locked;
        try {
            //SET_IF_ABSENT --> NX: Only set the key if it does not already exist.
            //SET_IF_PRESENT --> XX: Only set the key if it already exist.
            locked = (Boolean) redisTemplate.execute((RedisCallback<Boolean>) connection ->
                    connection.set(key.getBytes(StandardCharsets.UTF_8), value.getBytes(StandardCharsets.UTF_8),
                            Expiration.from(timeout, timeUnit), RedisStringCommands.SetOption.SET_IF_ABSENT));
        } catch (Exception e) {
            log.error("Lock failed for redis key: {}, value: {}", key, value);
            locked = false;
        }
        return locked != null && locked;
    }

    //redis解锁
    private boolean unlock(String key, String value) {
        try {
            //使用lua脚本保证删除的原子性，确保解锁
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] " +
                            "then return redis.call('del', KEY[1]) " +
                            "else return o end)";
            Boolean unlockState = (Boolean) redisTemplate.execute((RedisCallback<Boolean>) connection ->
                    connection.eval(script.getBytes(), ReturnType.BOOLEAN, 1,
                            key.getBytes(StandardCharsets.UTF_8), value.getBytes(StandardCharsets.UTF_8)));
            return unlockState == null || !unlockState;
        } catch (Exception e) {
            log.error("unLock failed for redis key: {}, value: {}", key, value);
            return false;
        }
    }
}

4.业务调用实现分布式锁示例：

    @Override
    public int updateById(CustomerBalance customerBalance) throws Exception {
        return redisService.callWithLock(customerBalance, ()-> customerBalanceMapper.updateById(customerBalance));
    }

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

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

相关文章

[附源码]计算机毕业设计JAVA高校创新创业项目管理系统

[附源码]计算机毕业设计JAVA高校创新创业项目管理系统

[附源码]计算机毕业设计JAVA高校创新创业项目管理系统 项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM…
阅读更多...
数字化转型重塑企业竞争优势，SaaS电商系统助力锂电池行业实现降本增效

数字化转型重塑企业竞争优势，SaaS电商系统助力锂电池行业实现降本增效

作为我国核心基础工业的关键材料之一&#xff0c;锂电池在汽车、医疗器械、航天航空、消费类电子产品等领域均可发挥重要作用。近年来&#xff0c;随着新能源汽车的快速发展有力带动了锂电池行业的市场需求&#xff0c;锂电池已成为化学电源应用领域中最具竞争力的电池&#xf…
阅读更多...
Vue | Vue.js 实现过渡动画

Vue | Vue.js 实现过渡动画

&#x1f5a5;️ Vue .js专栏&#xff1a;Vue .js 实现过渡动画 &#x1f9d1;‍&#x1f4bc; 个人简介&#xff1a;一个不甘平庸的平凡人&#x1f36c; ✨ 个人主页&#xff1a;CoderHing的个人主页 &#x1f340; 格言: ☀️ 路漫漫其修远兮,吾将上下而求索☀️ &#x1f44…
阅读更多...
基于51单片机的智能路灯控制系统proteus仿真原理图PCB

基于51单片机的智能路灯控制系统proteus仿真原理图PCB

功能&#xff1a; 0.本系统采用STC89C52作为单片机 1.LCD1602液晶实时显示当前时间/环境光强/工作模式 2.支持路灯故障检测 3.工作时间内(17~24时)&#xff0c;两个路灯同时点亮&#xff0c;24时以后&#xff0c;B路灯关闭&#xff0c;若检测到由物体通过&#xff0c;路灯B点亮…
阅读更多...
R17 redcap

R17 redcap

微信同步更新欢迎关注同名modem协议笔记 在5G时代&#xff0c;某些场景的终端并不需要特别复杂&#xff0c;只要满足成本低&#xff0c;功耗小&#xff0c;尺寸小等要求即可&#xff0c;例如视频监控&#xff0c;可穿戴设备&#xff0c;工业无线传感器等&#xff0c;redcap就是…
阅读更多...
electron vue 模仿qq登录界面

electron vue 模仿qq登录界面

1、使用vuecli创建vue项目 我用的vue2 vue create qq_test2、安装electron npm install electron -g //or npm install electron12.0.11 //老版本3、vue项目安装Electron-builder打包工具 版本我选择的是12 vue add electron-builder4、在vue项目的src下有个background.…
阅读更多...
收藏｜多指标时序预测方式及时序特征工程总结

收藏｜多指标时序预测方式及时序特征工程总结

背景 现如今&#xff0c;随着企业业务系统越来越复杂&#xff0c;单指标时间序列预测已不能满足大部分企业需求。在复杂的系统内&#xff0c;如果采用单一的指标进行时间序列预测&#xff0c;由于各个指标相互作用的关系&#xff0c;因此会因为漏掉部分指标因素导致出现预测精…
阅读更多...
进程间的通信 - 剪切板

进程间的通信 - 剪切板

剪切板是系统维护管理的一块内存区域&#xff0c;本机的所有进程都可以访问。当一个进程复制数据时&#xff0c;先将数据放在该内存区&#xff0c;当另一个进程粘贴时&#xff0c;则是从该内存区块取出数据 剪切板操作&#xff1a; 其实在剪切板中也就那几个API在使用&#x…
阅读更多...
tf模型落地安卓之旧事重提

tf模型落地安卓之旧事重提

之前将tf模型落地安卓了&#xff0c;其实就是clone一下官方的代码&#xff0c;然后配置下环境就打包了&#xff0c;没啥技术含量&#xff0c;现在再看&#xff0c;问题就在环境配置了。 1&#xff0c;Unable to start the daemon process. Q Group 277356808 The project use…
阅读更多...
西安某1000M3浮顶油罐设计（成品油库1000m³油罐设计与制造工艺）

西安某1000M3浮顶油罐设计（成品油库1000m³油罐设计与制造工艺）

目 录 1 浮顶油罐及其发展概况 2 2 设计方案 3 2.1 各种设计方法 3 2.2 各种方法优缺点比较 3 2.3 油罐的基础 4 3 罐壁设计 5 3.1 罐壁的强度计算 5 3.2 浮顶油罐的风力稳定计算 6 3.3 浮顶油罐的抗震计算 9 3.4 罐壁结构 14 4 罐底设计 18 4.1 罐底结构设计 18 4.2 罐底的应…
阅读更多...
【离散数学】第三章 测试

【离散数学】第三章 测试

1.单选题 A&#xff1d;{1,2,3},A上关系R{<1,2>,<2,2>,<2,3>,<3,3>}&#xff0c;则t(R) A. {<1,2>,<2,2>,<2,3>,<3,3>} B. {<1,2>,<1,3>,<2,2>,<2,3>,<3,3>} C. {<1,1>,<2,2>,<…
阅读更多...
【面试宝典】Spring Boot 系列面试题

【面试宝典】Spring Boot 系列面试题

1、什么是 Spring Boot? 多年来&#xff0c;随着新功能的增加&#xff0c;spring 变得越来越复杂。如果必须启动一个新的 Spring 项目&#xff0c;我们必须添 加构建路径或添加 Maven 依赖关系&#xff0c;配置应用程序服务器&#xff0c;添加 spring 配置。 因此&#xff0c…
阅读更多...
Vue（九）——页面路由（1）

Vue（九）——页面路由（1）

目录 路由的简介 路由基本使用 几个注意点 嵌套&#xff08;多级&#xff09;路由 路由的query参数 命名路由 路由的params参数 路由的props配置 路由的简介 理解&#xff1a; 一个路由&#xff08;route&#xff09;就是一组映射关系&#xff08;key - value&#xff…
阅读更多...
【毕业设计】深度学习身份证识别系统 - 机器视觉 python

【毕业设计】深度学习身份证识别系统 - 机器视觉 python

文章目录0 前言1 实现方法1.1 原理1.1.1 字符定位1.1.2 字符识别1.1.3 深度学习算法介绍1.1.4 模型选择2 算法流程3 部分关键代码4 效果展示5 最后0 前言 &#x1f525; Hi&#xff0c;大家好&#xff0c;这里是丹成学长的毕设系列文章&#xff01; &#x1f525; 对毕设有任…
阅读更多...
第八章： 项目质量管理

第八章： 项目质量管理

一、规划质量管理 识别项目及其可交付成果的质量要求和标准&#xff0c;并书面描述项目将如何证明符合质量要求和标准的过程。主要作用为整个项目期间如何管理和核实质量提供指南和方向。 输入工具与技术输出 1.项目章程 2.项目管理计划 需求管理计划风险管理计划相关方参与计…
阅读更多...
C++ opencv图像直方图

C++ opencv图像直方图

1.图像直方图概念 图像有很多基础概念&#xff0c;在我们学习的过程中因为一些原因无法涉及&#xff0c;但这并不代表它们不重要 今天&#xff0c;我们就来介绍一个概念——图像直方图 图像直方图&#xff0c;是图像处理中很重要的一个基础概念&#xff0c; 有很多的算法&…
阅读更多...
用HTML+CSS做一个漂亮简单的旅游网站——旅游网页设计与实现(6页)HTML+CSS+JavaScript

用HTML+CSS做一个漂亮简单的旅游网站——旅游网页设计与实现(6页)HTML+CSS+JavaScript

&#x1f468;‍&#x1f393;学生HTML静态网页基础水平制作&#x1f469;‍&#x1f393;&#xff0c;页面排版干净简洁。使用HTMLCSS页面布局设计,web大学生网页设计作业源码&#xff0c;这是一个不错的旅游网页制作&#xff0c;画面精明&#xff0c;排版整洁&#xff0c;内容…
阅读更多...
（八）Java算法：堆排序（详细图解）

（八）Java算法：堆排序（详细图解）

目录一、前言1.1、概念1.2、大根堆特点二、maven依赖三、流程解析3.1、初始建堆3.2、堆化第一步3.2、堆化第二步3.3、堆化第三步3.4、堆化第四步3.5、堆化第五步3.6、堆化第六步四、编码实现4.1、代码实现4.2、运行结果&#xff1a;扩展一、前言 1.1、概念 根据堆的结构可以分…
阅读更多...
彩印图文版《Elasticsearch实战》文档，阿里内部共享，堪称精品

彩印图文版《Elasticsearch实战》文档，阿里内部共享，堪称精品

学习是一种基础性的能力。然而&#xff0c;“吾生也有涯&#xff0c;而知也无涯。”&#xff0c;如果学习不注意方法&#xff0c;则会“以有涯随无涯&#xff0c;殆矣”。 学习就像吃饭睡觉一样&#xff0c;是人的一种本能&#xff0c;人人都有学习的能力。我们在刚出生的时候…
阅读更多...
Lesson1强化学习（RL）初印象 学习笔记

Lesson1强化学习（RL）初印象 学习笔记

一、强化学习引入 ​ 人的智能可以遗传获得也可以通过后天学习&#xff1b;学习有两种&#xff0c;模仿前人的经验是一种学习&#xff1b;如果没有前人的经验可以学习&#xff0c;就需要和环境进行交互&#xff0c;得到反馈来学习。 #mermaid-svg-XUxguPj6VHcJMK3W {font-famil…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023