• 分布式锁-简单入门

    状态不是很好，记一下以前学过的分布式锁吧。

    样例简介

    不谈大概念，就是简单入门以及使用。

    为什么要用分布式锁呢？

    假设我需要一个定时操作，每天在某个点，我要处理一批数据，要先从数据库中查询出来（IO操作），然后再逐步处理数据（CPU操作）。这些数据之间没有关联关系，不需要考虑数据执行的先后顺序。

    单机思路

    在单机情况下，做法是什么。开启一个定时任务，该任务中，查询数据库得到所有数据并加载到内存中。在内存中，我可以通过JUC的一些工具类，LinkedBlockingQueue保证线程安全的情况下移除元素，一个个的来处理。这是一种多线程的方案。

    那么多进程呢，集群情况下，多台主机，该怎么处理。

    多进程思路

    分布式锁结合MQ实现解决方案。我说一下个人想法的一种解决方法，具体操作：

    1.要定时处理数据，肯定是需要定时任务的。那么，三台主机都配置了定时任务。但是，从数据库中查询出数据的这一步我却只想执行一次，而不是三个主机各执行一次。在这里，就用到分布式锁了，我们可以使用tryLock方式，对其进行试图获取锁，同一个时刻，肯定只有一个任务获取到锁。剩下的两个获取失败就不执行了。我们就获取到这个数据。

    2.在获取到这个数据后，可以选择将查询到数据推送至MQ，然后三台主机作为消费者，来有效提升系统的执行速率。

    这是我内心中比较倾向的一种解决方式。性能相对高一点。

    想想不高的，如同单机的这种方式，我们该怎么实现（不涉及中间件这种）。说一个相对耗性能的方案。也利用了分布式锁。

    我要处理的数据，这个数据表中我加一个状态，0标识未处理，1标识处理。

    1.加分布式锁。

    2.查询出数据表中状态为0的单条数据。

    3.做涉及到这条数据的一系列业务操作。

    4.修改当前数据的状态为1。

    5.解分布式锁。

    有多少条数据就得加锁解锁多少次，以及查询多次数据库。性能的低下可想而之。

    代码

    例子说完了，用代码来体现一下。分布式锁我采用的是reddision的方式。这里就为了代码简单，模拟一个火车票数量减少的操作。（数据虽然放到redis了，而且redis执行是单线程的，但可以java代码将减少这个操作的过程设置为线程不安全的操作，这个样例中我是这么做的）。

    POM文件

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     <modelVersion>4.0.0modelVersion>
    5.     <groupId>com.bogroupId>
    6.     <artifactId>distributed-lock-threeartifactId>
    7.     <version>0.0.1-SNAPSHOTversion>
    8.     <name>distributed-lock-threename>
    9.     <description>distributed-lock-threedescription>
    10.  
    11.     <properties>
    12.         <java.version>1.8java.version>
    13.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    14.         <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
    15.         <spring-boot.version>2.3.7.RELEASEspring-boot.version>
    16.     properties>
    17.  
    18.     <dependencies>
    19.         <dependency>
    20.             <groupId>com.alibabagroupId>
    21.             <artifactId>fastjsonartifactId>
    22.             <version>2.0.17version>
    23.         dependency>
    24.  
    25.         <dependency>
    26.             <groupId>org.springframework.bootgroupId>
    27.             <artifactId>spring-boot-devtoolsartifactId>
    28.             <version>${spring-boot.version}version>
    29.             <scope>runtimescope>
    30.             <optional>trueoptional>
    31.         dependency>
    32.         <dependency>
    33.             <groupId>org.projectlombokgroupId>
    34.             <artifactId>lombokartifactId>
    35.             <version>1.18.24version>
    36.             <optional>trueoptional>
    37.         dependency>
    38.         <dependency>
    39.             <groupId>org.springframework.bootgroupId>
    40.             <artifactId>spring-boot-starter-testartifactId>
    41.             <version>${spring-boot.version}version>
    42.             <scope>testscope>
    43.             <exclusions>
    44.                 <exclusion>
    45.                     <groupId>org.junit.vintagegroupId>
    46.                     <artifactId>junit-vintage-engineartifactId>
    47.                 exclusion>
    48.             exclusions>
    49.         dependency>
    50.         <dependency>
    51.             <groupId>org.springframework.bootgroupId>
    52.             <artifactId>spring-boot-autoconfigureartifactId>
    53.             <version>${spring-boot.version}version>
    54.         dependency>
    55.         <dependency>
    56.             <groupId>org.springframework.bootgroupId>
    57.             <artifactId>spring-boot-starter-webartifactId>
    58.         dependency>
    59.         
    60.         <dependency>
    61.             <groupId>org.springframeworkgroupId>
    62.             <artifactId>spring-contextartifactId>
    63.             <version>5.2.12.RELEASEversion>
    64.         dependency>
    65.  
    66.         <dependency>
    67.             <groupId>org.redissongroupId>
    68.             <artifactId>redissonartifactId>
    69.             <version>3.17.7version>
    70.         dependency>
    71.     dependencies>
    72.  
    73.     <dependencyManagement>
    74.         <dependencies>
    75.             <dependency>
    76.                 <groupId>org.springframework.bootgroupId>
    77.                 <artifactId>spring-boot-dependenciesartifactId>
    78.                 <version>${spring-boot.version}version>
    79.                 <type>pomtype>
    80.                 <scope>importscope>
    81.             dependency>
    82.         dependencies>
    83.     dependencyManagement>
    84.  
    85.     <build>
    86.         <plugins>
    87.             <plugin>
    88.                 <groupId>org.apache.maven.pluginsgroupId>
    89.                 <artifactId>maven-compiler-pluginartifactId>
    90.                 <version>3.8.1version>
    91.                 <configuration>
    92.                     <source>1.8source>
    93.                     <target>1.8target>
    94.                     <encoding>UTF-8encoding>
    95.                 configuration>
    96.             plugin>
    97.             <plugin>
    98.                 <groupId>org.springframework.bootgroupId>
    99.                 <artifactId>spring-boot-maven-pluginartifactId>
    100.                 <version>2.3.7.RELEASEversion>
    101.                 <configuration>
    102.                     <mainClass>com.bo.distributedlockthree.DistributedLockThreeApplicationmainClass>
    103.                 configuration>
    104.                 <executions>
    105.                     <execution>
    106.                         <id>repackageid>
    107.                         <goals>
    108.                             <goal>repackagegoal>
    109.                         goals>
    110.                     execution>
    111.                 executions>
    112.             plugin>
    113.         plugins>
    114.     build>
    115.  
    116. project>

    Redisson注册的代码

    1. package com.bo.distributedlockthree.test.config;
    2.  
    3.  
    4. import org.redisson.Redisson;
    5. import org.redisson.api.RedissonClient;
    6. import org.redisson.config.Config;
    7. import org.springframework.context.annotation.Bean;
    8. import org.springframework.stereotype.Component;
    9.  
    10. /**
    11.  * @Auther: zeroB
    12.  * @Date: 2022/11/14 09:53
    13.  * @Description:
    14.  */
    15. @Component
    16. public class TestDistributedLockConfig {
    17.     @Bean
    18.     public RedissonClient redissonClient(){
    19.         Config config = new Config();
    20.         config.useSingleServer().setAddress("redis://192.168.140.130:6379").setPassword("2wsx@WSX");
    21.         RedissonClient redissonClient = Redisson.create(config);
    22.         return redissonClient;
    23.     }
    24.  
    25.  
    26. }

    返回结果类

    1. package com.bo.distributedlockthree.test.pojo;
    2.  
    3. import java.io.Serializable;
    4.  
    5. /**
    6.  * @Auther: zeroB
    7.  * @Date: 2022/11/14 11:10
    8.  * @Description:
    9.  */
    10. public class ResultVO implements Serializable {
    11.     private boolean isSuccess;
    12.  
    13.     private String errorMsg;
    14.  
    15.     private T data;
    16.  
    17.     public boolean isSuccess() {
    18.         return isSuccess;
    19.     }
    20.  
    21.     public void setSuccess(boolean success) {
    22.         isSuccess = success;
    23.     }
    24.  
    25.     public String getErrorMsg() {
    26.         return errorMsg;
    27.     }
    28.  
    29.     public void setErrorMsg(String errorMsg) {
    30.         this.errorMsg = errorMsg;
    31.     }
    32.  
    33.     public T getData() {
    34.         return data;
    35.     }
    36.  
    37.     public void setData(T data) {
    38.         this.data = data;
    39.     }
    40. }

    工具代码

    1. package com.bo.distributedlockthree.test.action;
    2.  
    3. import com.bo.distributedlockthree.test.config.properties.ApplicationUtils;
    4. import com.bo.distributedlockthree.test.pojo.ResultVO;
    5. import lombok.extern.slf4j.Slf4j;
    6. import org.redisson.api.RAtomicLong;
    7. import org.redisson.api.RLock;
    8. import org.redisson.api.RedissonClient;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.stereotype.Controller;
    11. import org.springframework.util.StringUtils;
    12. import org.springframework.web.bind.annotation.RequestMapping;
    13. import org.springframework.web.bind.annotation.ResponseBody;
    14.  
    15. import java.util.ArrayList;
    16. import java.util.List;
    17.  
    18. /**
    19.  * @Auther: zeroB
    20.  * @Date: 2022/11/14 09:48
    21.  * @Description:
    22.  */
    23. @Controller
    24. @Slf4j
    25. public class TestAction {
    26.     @Autowired
    27.     private RedissonClient redissonClient;
    28.  
    29.     @Autowired
    30.     private ApplicationUtils applicationUtils;
    31.  
    32.     /**
    33.      * 在redis中添加共享数据
    34.      */
    35.     @RequestMapping("testAddData")
    36.     @ResponseBody
    37.     public void testAddData(){
    38.         RAtomicLong atomicLong = redissonClient.getAtomicLong("ticketCount");
    39.         long l = atomicLong.addAndGet(1000L);
    40.         log.info("存放至redis中的数据为{}",l);
    41.     }
    42.  
    43.  
    44.     /**
    45.      * 测试下分布式锁，多进程共享数据存放至redis中
    46.      */
    47.     @RequestMapping("/testLock")
    48.     @ResponseBody
    49.     public String testLock(){
    50.  
    51.         RLock testLock = redissonClient.getLock("testLock");
    52.         long l = 0L;
    53.         try{
    54.             testLock.lock();
    55.             RAtomicLong ticketCount = redissonClient.getAtomicLong("ticketCount");
    56.             long l1 = ticketCount.get();
    57.             //如果这里不加判定，是不会存在异常的，但加上的话，就有可能出现减为0的情况了
    58.             if(l1 <= 0){
    59.                 log.info("销售完成，销售数量为{}",l1);
    60.                 throw new UnsupportedOperationException("销售完成，已不支持");
    61.             }
    62.             //这里感觉用过CAS了，本质上已经同步处理过了
    63.             Thread.sleep(500);
    64.             l = ticketCount.decrementAndGet();
    65.             log.info("减去后的值为"+l);
    66.         } catch (InterruptedException e) {
    67.             e.printStackTrace();
    68.         } finally {
    69.             testLock.unlock();
    70.             return String.valueOf(l);
    71.         }
    72.     }
    73.  
    74.     /**
    75.      * 得到容器内存放所有元素
    76.      * @param name 容器内元素名称
    77.      * @return
    78.      * TODO 前端序列化传输展示存在问题，先不考虑这个问题
    79.      */
    80.     @RequestMapping("/listContainerData")
    81.     @ResponseBody
    82.     public ResultVO> listContainerData(String name){
    83.         ResultVO> listResultVO = new ResultVO<>();
    84.         if(StringUtils.isEmpty(name)){
    85.             log.info("查询出全部的容器内容");
    86.             listResultVO.setData(applicationUtils.listBean());
    87.             return listResultVO;
    88.         }
    89.         List objects = new ArrayList<>();
    90.  
    91.         //需要序列化
    92.         objects.add(applicationUtils.getBean(name));
    93.  
    94.         listResultVO.setData(objects);
    95.         return listResultVO;
    96.     }
    97.  
    98.     /**
    99.      * 分布式锁测试tryLock方案的问题
    100.      * @return
    101.      */
    102.     @RequestMapping("tryLockTest")
    103.     @ResponseBody
    104.     public ResultVO tryLockTest(){
    105.         RLock testLock = redissonClient.getLock("testLock");
    106.         ResultVO resultVO = new ResultVO<>();
    107.  
    108.         long l1 = 0L;
    109.         //相当于结合CAS的dowhile循环,只有获取到锁的情况下，执行了我要执行的任务，结束了，所有的请求我都要得到并处理
    110.         //但这样，一直获取不到锁，进程饥渴的情况下，会一直占用CPU，阻塞的，这个得想想方案
    111.         while(true){
    112.             //这块应该得加锁，因为这个值结果和判断条件是相关的，假如我不放到锁中的话
    113.             /**
    114.              * 1.我得到count是0了
    115.              * 2.此时其它进程得到系统的值然后操作
    116.              * 3.此时实际是小于0了，但依旧正常操作
    117.              */
    118.             if(!testLock.tryLock()){
    119.                 continue;
    120.             }
    121.             try{
    122.                 RAtomicLong ticketCount = redissonClient.getAtomicLong("ticketCount");
    123.                 long l = ticketCount.get();
    124.                 if(l <= 0){
    125.                     log.info("售票已经执行完成了，售票结果为{}",l);
    126.                     throw new UnsupportedOperationException("售票已经执行完成了，售票结果为"+l);
    127.                 }
    128.  
    129.                 Thread.sleep(100);
    130.                 l1 = ticketCount.decrementAndGet();
    131.                 log.info("销售完成的结果为{}",l1);
    132.             } catch (InterruptedException e) {
    133.                 e.printStackTrace();
    134.             } finally {
    135.                 testLock.unlock();
    136.                 resultVO.setData(String.valueOf(l1));
    137.                 return resultVO;
    138.             }
    139.         }
    140.  
    141.     }
    142.  
    143.  
    144. }
      145.  

      总结
       

      上述的测试可以通过，只是一个简单样例，来理解一下它的思想。其实真正使用的时候吧，配置之类的肯定是不简单的。我也没有实际生产用过，只是先提供给大家一个思路。
       

      附上Redisson官方文档地址,有中文实在太贴心了：
       

      目录 · redisson/redisson Wiki · GitHubicon-default.png?t=M85Bhttps://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95
       

      
                
                    
                

                
    145. 

                    相关阅读:
      
                    
wait/notify                            
      
【MySQL】库和表的操作                            
      
UE4实现光束和体积雾                            
      
C【文件操作】                            
      
经纬恒润推出全新一代智能电动座椅模块                            
      
springboot中aop的代理模式                            
      
【PID优化】基于头脑风暴算法PID控制器优化设计含Matlab源码                            
      
Java 异常处理                            
      
SpringBoot：（五）自动配置原理解析                            
      
全球化浪潮下的数据库革新：嘉里物流 TiDB 实践价值的设想                            
      
                          
                
      146. 
                
    146. 
                    原文地址：https://blog.csdn.net/key_wu/article/details/127986347
                
      147.