八：分布式锁

最新推荐文章于 2024-06-21 14:28:40 发布
最新推荐文章于 2024-06-21 14:28:40 发布
阅读量942 收藏 20
点赞数 19
文章标签： 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51318621/article/details/135581365
版权

1、为什么要使用分布式锁

  1. 锁是多线程代码中的概念，只有多任务访问同一个互斥的共享资源时才需要锁。
  2. 单机应用开发时一般使用synchronized或lock。多线程的运行都是在同一个JVM之下。
  3. 应用是分布式集群，属于多JVM的工作环境，JVM之间已经无法通过多线程的锁解决同步问题。

 

2、分布式锁的几种方式

分布式锁的核心思路是借助外力 解决多JVM进程操作共享数据时需要使用互斥锁的问题。

常见的方式 有：

  1. mysql数据库分布式锁
  2. zookeeper分布式锁
  3. redis分布式锁

3、搭建测试分布式锁的环境

【1】创建工程distributed-lock-study ，pom如下

父工程

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.lyx</groupId>
    <artifactId>distributed-lock-study</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <name>distributed-lock-study</name>
    <description>distributed-lock-study</description>
    <modules>
        <module>moduleA</module>
        <module>moduleB</module>
    </modules>
    <properties>
        <java.version>8</java.version>
        <dubbo.starter>2.7.6</dubbo.starter>
        <dubbo.registry.zookeeper>2.7.6</dubbo.registry.zookeeper>
        <mysql-connection.version>8.0.26</mysql-connection.version>
        <druid.version>1.2.1</druid.version>
        <mybatis-plus.version>3.5.2</mybatis-plus.version>
        <hutool.version>5.7.17</hutool.version>
    </properties>
<dependencyManagement>
    <dependencies>
        <!-- Dubbo 依赖 -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>${dubbo.starter}</version>
        </dependency>
        <!-- zookeeper 注册中心 依赖 -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-registry-zookeeper</artifactId>
            <version>${dubbo.registry.zookeeper}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-connection.version}</version>
            <scope>runtime</scope>
        </dependency>
        <!--druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!--mybatis-plus依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>
        <!--hutool-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>${hutool.version}</version>
        </dependency>

    </dependencies>

</dependencyManagement>

</project>

 【2】创建moduleA和moduleB两个模块

依赖：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.lyx</groupId>
        <artifactId>distributed-lock-study</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <groupId>org.example</groupId>
    <artifactId>moduleA</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mybatis-plus依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>
        <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--common-pool-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!--  Redisson分布式锁使用-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.14.0</version>
        </dependency>
        <!--基于Curator 客户端（zookeeper的）实现分布式锁 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>4.0.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

 【3】在两个模块中编写application.yml

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/lock_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
  redis:
    host: 192.168.184.200
    port: 6379
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 100ms
server:
  port: 1111 # 两个模块的端口号不一样，其他一样

【4】编写启动类

@SpringBootApplication
@MapperScan("top.psjj.ma.mapper")
public class ModuleAApplication {
    public static void main(String[] args) {
        SpringApplication.run(ModuleAApplication.class,args);
    }
}

 【5】准备数据库local_db,并出入下张表

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for t_goods
-- ----------------------------
DROP TABLE IF EXISTS `t_goods`;
CREATE TABLE `t_goods`  (
  `id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `goods` varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL,
  `count` int(0) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_unicode_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of t_goods
-- ----------------------------
INSERT INTO `t_goods` VALUES (1, '手机', -1);
INSERT INTO `t_goods` VALUES (2, '笔记本', 100);

SET FOREIGN_KEY_CHECKS = 1;

 【6】编写po 、mapper 、service 、controller,两个模块代码完全一样

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_goods")
public class Goods implements Serializable {
    @Serial
    private static final long serialVersionUID = -9084934747907815210L;
    @TableId(type = IdType.AUTO)
    private Integer id;
    private String goods;
    private Integer count;
}
public interface GoodsMapper extends BaseMapper<Goods> {
    @Update("update t_goods set count = count-1 where id=#{id}")
    void subCount(Integer id);
}

public interface GoodsService extends IService<Goods> {
    void updateGoodsCount(Integer id);
}

@Service
public class GoodsServiceImpl extends ServiceImpl<GoodsMapper, Goods> implements GoodsService {
    @Override
    public void updateGoodsCount(Integer id) {
        Goods goods = this.baseMapper.selectById(id);
        Integer count = goods.getCount();
        if(count>0){
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            this.baseMapper.subCount(id);
        }
    }
}
@RestController
@RequestMapping("/goods")
public class GoodsController {
    @Autowired
    private GoodsService goodsService;

    @RequestMapping("/update")
    public String updateGoodsCount(Integer id){
        goodsService.updateGoodsCount(id);
        return "ok";
    }
}

 

4、基于Mysql实现的分布式锁

4.1 mysql实现分布式锁原理

  • 首先单独分离出一台mysql数据库，所有服务要想操作文件（共享资源），那么必须先在mysql数据库中插入一个标志，插入标志的服务就持有了锁，并对文件进行操作 。
  • 操作完成后，主动删除标志进行锁释放，其余服务会一直查询数据库，看是否标志有被占用，直到没有标志占用时自己才能写入标志获取锁。

4.2  问题

  1. 如果服务（jvm1）宕机或者卡顿了，会一直持有锁未释放，造成死锁。因此需要一个监视锁进程，时刻监视锁的状态，如果超过一定时间未释放就要进行主动清理锁标记，然后供其他服务继续获取锁。
  2. 如果监视锁字段进程和jvm1同时挂掉，依旧不能解决死锁问题，于是又增加一个监视锁字段进程，这样一个进程挂掉，还有另一个监视锁字段进程可以对锁进行管理。
  3. 但是又诞生一个新的问题，两个监视进程必须进行同步，否则对于过期的情况管理存在不一致问题。

因此存在以下问题，并且方案变得很复杂：

  1. 监视锁字段进程对于锁的监视时间周期过短，仍旧会造成多售（jvm1还没处理完其持有的锁就被主动销毁，造成多个服务同时持有锁进行操作）。

  2. 监视锁字段进程对于锁的监视时间周期过长，会造成整个服务卡顿过长，吞吐低下。

  3. 多个监视锁字段进程间的同步问题。

  4. 当一个jvm持有锁的时候，其余服务会一直访问数据库查看锁，会造成其余jvm的资源浪费。

4.2 基于update实现分布锁（特殊情况）

关于分布式锁，因为代码直接执行语句，有数据库行级锁，不会产生超卖问题。

mysql行锁解决分布锁问题演示修改的代码： 

ServiceImpl中：

//mysql行锁解决分布锁问题
try {
    Thread.sleep(5000);
} catch (InterruptedException e) {
    throw new RuntimeException(e);
}
this.baseMapper.subCount2(goods);

mapper中： 

@Update("update t_goods set count=count-1 where id=#{id} and count>0")
void subCount2(Goods goods);

 

5、基于Redis实现分布式锁

 

5.1 Redis实现分布式锁优点

（1）Redis有很高的性能； 

（2）Redis命令对此支持较好，实现起来比较方便

命令介绍:

setnx ：

SETNX key val：当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。

expire :

expire key timeout：为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。

delete :

 delete key：删除key

 在使用Redis实现分布式锁的时候，主要就会使用到这三个命令。

 

5.2 Redis实现分布式锁原理

  1. 获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。
  2. 获取锁的时候还设置一个获取的超时时间，若超过这个时间则放弃获取锁。
  3. 释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。

 

5.3 Redisson分布式锁使用

1)引入依赖

<!--  Redisson分布式锁使用-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.14.0</version>
</dependency>

2)配置文件

spring:
  redis:
    host: 192.168.220.110
    port: 6379

3)代码实现

//创建锁
RLock lock = redissonClient.getLock("goods-" + id);
//加锁
try {
    lock.lock();
    Goods goods = this.baseMapper.selectById(id);
    Integer count = goods.getCount();
    if(count>0){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        this.baseMapper.subCount(id);
    }
} catch (RuntimeException e) {
    throw new RuntimeException("超卖了");
} finally {
    //释放锁
    lock.unlock();
}

5.4 总结

可以使用缓存代替数据库实现分布式锁，性能根号。同时多数缓存服务时集群部署，可以避免单点问题。

很多缓存服务提供了实现分布式锁的方法和对数据过期自动删除的支持，如Tair的put方法，redis 的setnx方法(Redisson是Redis官方推荐的Java版的Redis客户端) 。可以设置超时时间控制锁的释放。

使用缓存实现分布式锁的优点：性能好，实现起来较为方便。

使用缓存实现分布式锁的缺点 ：通过超时时间来控制所得失效时间不靠谱。

6、 基于Zookeeper实现的分布式锁

6.1 Zookeeper的特点

Zookeeper的每一个节点，都是一个天然的顺序发号器，zookeeper有以下特点：

  1. 维护了一个有层次的数据节点，类似文件系统。

  2. 有临时节点，持久节点，临时有序节点（分布式锁实现基于的数据节点) ，持久有序节点。

  3. zookeeper可以和client客户端通过心跳机制保持长连接，断开连接自动删除临时节点。

  4. zookeeper的节点上可以注册上用户事件(自定义)，节点数据删除等事件都可以触发自定义事件。

  5. zookeeper保持了统一视图，各服务对于状态信息获取满足一致性。

创建有序节点会有编号：

6.2 Zookeeper实现分布式锁原理

  1. 创建一个目录mylock；

  2. 线程A想获取锁就在mylock目录下创建临时顺序节点；

  3. 获取mylock目录下所有的子节点，然后获取比自己小的兄弟节点，如果不存在，则说明当前线程顺序号最小，获得锁；

  4. 线程B获取所有节点，判断自己不是最小节点，设置监听比自己小的节点；

  5. 线程A处理完，删除自己的节点，线程B监听到变更事件，判断自己是不是最小的节点，如果是则获得锁。

6.3 Zookeeper解决的问题

锁无法释放？

在创建锁的时候，客户端会在ZK中创建一个临时节点，一旦客户端获取到锁之后突然挂掉（Session连接断开），那么这个临时节点就会自动删除掉。锁就会释放。

非阻塞锁？

客户端可以通过在ZK中创建顺序节点，并且在节点上绑定监听器，一旦节点有变化，Zookeeper会通知客户端，客户端可以检查自己创建的节点是不是序号最小，如果是，那么自己就获取到锁。

不可重入？  

客户端在创建节点的时候，把当前客户端的主机信息和线程信息直接写入到节点中，下次想要获取锁的时候和当前最小的节点中的数据比对。如果信息一样，直接获取到锁，如果不一样就再创建一个临时的顺序节点，参与排队。

单点问题？

ZK是集群部署的，只要集群中有半数以上的机器存活，就可以对外提供服务。　　

6.4 基于Curator 客户端实现分布式锁

Curator Framework提供了简化使用zookeeper更高级的API接口。它包涵很多优秀的特性，主要包括以下三点

  1. 自动连接管理：自动处理zookeeper的连接和重试存在一些潜在的问题；可以watch NodeDataChanged event和获取updateServerList;Watches可以自动被Cruator recipes删除；

  2. 更干净的API：简化raw zookeeper方法，事件等；提供现代流式API接口

  3. Recipe实现：leader选举，分布式锁，path缓存，和watcher,分布式队列等。

 依赖：

<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>4.0.1</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>4.0.1</version>
</dependency>

代码：

//zookeeper 分布式锁解决超卖问题
//1.创建zookeeper连接
RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
CuratorFramework client= CuratorFrameworkFactory.newClient("192.168.184.200:2181", retryPolicy);
client.start();
//创建分布式锁
InterProcessMutex interProcessMutex = new InterProcessMutex(client,"/ordersettinglock");
//加锁
try {
    interProcessMutex.acquire();
    Goods goods = this.baseMapper.selectById(id);
    Integer count = goods.getCount();
    if(count>0){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        this.baseMapper.subCount(id);
    }
} catch (Exception e) {
    throw new RuntimeException("超卖了");
} finally {
    //释放锁
    try {
        interProcessMutex.release();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

6.5 总结

优点:

有效的解决单点问题、不可重入问题、非阻塞问题、锁无法释放问题。实现起来简单。

缺点：

性能上不如使用缓存实现分布式锁。需要对ZK的原理有所了解，比较复杂 。

7、分布式锁总结

上面几种方式，哪种方式都无法做到完美。就像CAP一样，在复杂性、可靠性、性能等方面无法同时满足，所以，根据不同的应用场景选择最适合自己的才是王道。

理解难易程度：

数据库>缓存（redis) >zookeeper.

复杂性：

zookeeper  >= 缓存 > 数据库

性能：

缓存 > zookeeper >= 数据库

可靠性：
zookeeper > 缓存 >数据库

新手小菜鸟上路
关注
  • 19
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一窥：分布式、分布式缓存、分布式锁及其延申
qq_45643467的博客
09-01 333
传统的计算模型通常是集中式的，所有的计算任务和数据处理都由完成。然而，随着数据量和计算需求的增加，集中式系统可能会面临性能瓶颈和可靠性问题。故而引出了分布式↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓。
Redis系列教程(八)：分布式锁的由来、及Redis分布式锁的实现详解
一个有情怀的程序猿博客
05-19 459
在很多场景中，我们为了保证数据的最终一致性，需要很多的技术方案来支持，比如分布式事务、分布式锁等。那具体什么是分布式锁，分布式锁应用在哪些业务场景、如何来实现分布式锁呢？今天来探讨分布式锁这个话题。 什么是分布式锁 要介绍分布式锁，首先要提到与分布式锁相对应的是线程锁、进程锁。 1.线程锁 主要用来给方法、代码块加锁。当某个方法或代码使用锁，在同一时刻仅有一个线程执行该方法或该代码段。线程锁只在同一JVM中有效果，因为线程锁的实现在根本上是依靠线程之间共享内存实现的，比如Sy...
黑马redis学习记录：分布式锁
ZZDT099的博客
02-16 1525
黑马redis学习记录：分布式锁
面试八：分布式
a631258447的博客
08-19 200
1.什么是分布式系统？用过那些分布式系统？ 一个业务分拆多个子业务，部署在不同的服务器上。 2.分布式锁 1.基于数据库实现分布式锁 2.基于缓存redis实现分布式锁 （设置超时时间） 3.基于Zookeeper实现分布式锁（临时节点） 3.分布式缓存, redis、Memcached redis和Memcached区别 1 、Redis不仅仅支持简单的k/v类型的数据，同时还提供list，se...
分布式 锁
ChineseSoftware的博客
01-17 685
分布式实现全局锁的关键：用一个全局唯一的资源来满足资源竞争的顺序执行和原子性：1️⃣使用数据库实现。2️⃣使用缓存实现。 一、Java 原生锁的使用 在说分布式锁之前，先了解下 Java 的 synchronized，这种加锁方式可以针对某个方法或者某个代码块进行加锁，如： public void doInfo (String uid) { synchronized(uid.intern()) { //TODO } } 比如甲进来执行了 doInfo()，且还在 synchronized 代码
借读：分布式锁和双写Redis
weixin_34197488的博客
03-27 108
本帖最后由 howtodown 于 2016-10-3 16:01 编辑问题导读1.为什么会产生分布式锁？2.使用分布式锁的方法有哪些？3.本文创造的分布式锁的双写Redis框架都包含哪些内容？一、关于分布式锁 关于分布式锁，可能绝大部分人都会或多或少涉及到。我举二个例子：场景一：从前端界面发起一笔支付请求，如果前端没有做防重处理，那么可能在某一个时刻会有二笔一样的...
Redis从入门到精通（二）：分布式锁以及缓存相关问题
wufeifan_learner的博客
05-08 228
目录： Redis从入门到精通（一）：缓存 Redis从入门到精通（二）：分布式锁以及缓存相关问题 Redis从入门到精通（三）：Redis持久化算法以及内存淘汰策略 Redis从入门到精通（四）：Redis常用数据结构以及指令 Redis从入门到精通（五）：Redis6整合SpringBoot2.x+Mybatis+SpringCache Redis从入门到精通（六）：Redis高可用原理+实战 Redis从入门到精通（七）：待定 分布式架构 什么是分布式架构？ 很简单，那就是服务不放在同一台主机上，或者
Redis系列(八)：分布式锁服务
guoduhua的专栏
02-14 339
阅读目录： 概述分布式锁多实例分布式锁总结 概述 在多线程环境下，通常会使用锁来保证有且只有一个线程来操作共享资源。比如： object obj = new object(); lock (obj) { //操作共享资源 } 利用操作系统提供的锁机制，可以确保多线程或多进程下的并发唯一操作。但如果在多机环境下就不能满足了，当A，B两台机器同时操作C机器的共享资源时，就需
springboot微服务实战：分布式锁 Redisson 之八锁（Github-WIKI文档）与JUC下8锁相同原理
CTRA®王大大技术中心
10-19 284
1. 可重入锁（Reentrant Lock） 基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。 RLock lock = redisson.getLock("anyLock"); // 最常见的使用方法 lock.lock(); 大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状
distribute_lock:分布式锁
05-13
distribute_lock分布式锁：分别实现：redis:jedisredissionspring-data-rediszookeeper：zkclient(暂未实现)curator
zookeeper:基于Zookeeper的分布式锁
04-29
使用zookeeper来实现分布式锁 原理 监听zookeeper的临时有序节点，监听到NodeDeleted事件，就会让线程重新获取锁 测试方法 public class ZookeeperLockTest { public static void main(String[] args) throws ...
分布式多场景实战经验.docx
11-05
知识点八：分布式锁的实现注意点 分布式锁的实现需要注意以下几点： * 锁的创建和删除需要在同一个线程中进行 * 锁的持有者需要在规定的时间内释放锁 * 锁的过期时间需要设置合理 * 锁的删除需要在锁的有效期内...
Redis从入门到精通(八)Redis实战(五)分布式锁误删与原子性问题、Redisson 测试项目代码
04-06
测试项目代码
信息安全工程：第八章 分布式.pdf
07-04
为解决这个问题，系统通常采用锁机制来防止不一致更新，如回调机制、预授权等方法，以及使用Cookie等手段来管理用户登录状态。 【死锁问题】是并发控制中的另一难题，类似于哲学家就餐问题，系统需要避免资源的循环...
什么是OAuth2分布式授权协议？
最新发布
2401_83062316的博客
06-21 554
你可能也已经注意到，虽然说OAuth2协议解决的是授权问题，但它也应用到了认证的概念，因为只有验证了用户的身份凭证，我们才能完成对他的授权。以目前主流的微服架构而言，当我们发起HTTP请求时，关注的是如何通过HTTP协议透明而高效的传递令牌，授权码模式下通过回调地址进行授权管理的方式就不是很实用，密码模式反而更加简洁高效。授权码模式的特点在于当用户同意授权后，授权服务器不是马上返回最终的令牌，而是一个授权码，需要客户端携带授权码去换令牌，这就需要客户端自身具备与授权服务器进行直接交互的后台服务。
Harbor本地仓库搭建003_Harbor常见错误解决_以及各功能使用介绍_镜像推送和拉取---分布式云原生部署架构搭建003
添柴程序猿的专栏
06-18 205
然后点开这个镜像,可以看到对应的artifacts还有,他的tags,我们设站点1.15.12对吧。可以看到添加上,忽略的域名就可以了,让docker,对我们的地址,忽略https检测。首先我们去登录一下harbor,但是可以看到,用户名密码没有错,但是登录不上去。是因为,我们用了负债均衡,nginx会把,负载均衡进行,随机分配,访问的。的business这个项目,可以看到在镜像仓库中,就有了。登录以后,可以看到项目中,我们可以创建一个项目,比如。可以看到我们给,负载均衡,分发的时候,添加上。
Harbor本地仓库搭建002_Harbor负载均衡节点搭建_nginx安装配置_harbor安装---分布式云原生部署架构搭建002
添柴程序猿的专栏
06-18 270
Docker：Docker是一个开源的应用容器引擎，它允许开发者将他们的应用及其依赖打包到一个可移植的容器中，然后发布到任何流行的Linux或Windows操作系统的机器上。mv /opt/docker-compose-linux-x86_64 /usr/local/bin/docker-compose 将安装包解压以后,移动到对应目录。就需要在对应的system32/etc/driver ...找一下吧,忘记了,找到对应的hosts,修改一下就可以了。
WPF 程序 分布式 自动更新 登录 打包
cao919的专栏Net
06-19 875
测试了下开发环境的主流程部分跑起来了。生产环境使用 还有诸多细节处理。// 2、文件判断，新增的直接下载；坑对新手不是很友好。目测跑个测试环境都费劲。1文件对比 客户端本地对比upgrade_temp.json文件。// 客户端本地需要一个记录，最后更新的记录（）// 开始下载文件 从服务器上下载相关文件。先潦草的写下后面真能跑起来在来改吧。注意：关键点 坑点！//1、获取最新文件列表。
Sleuth：分布式跟踪
04-04
Sleuth是一款用于分布式跟踪的开源工具，它主要用于解决微服务架构中的跨服务调用问题。Sleuth基于Google的Dapper论文，实现了分布式跟踪的核心功能，包括生成唯一的跟踪ID、记录服务间的调用关系、计算调用时间等。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值