【Quarkus】基于Quarkus的注解@Lock进行读写锁的案例说明

最新推荐文章于 2023-03-01 18:58:33 发布
最新推荐文章于 2023-03-01 18:58:33 发布
阅读量548 收藏 1
点赞数
分类专栏： Quarkus专栏 Java专栏 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37875329/article/details/127893758
版权

…

好记性不如烂笔头，今天讨论讨论读写锁。

文章目录

阅读须知：本文使用Quarkus框架Java语言编写。

介绍

什么是读写锁？

  • 读写锁（Readers-Writer Lock）顾名思义就是读锁写锁，读锁允许多个线程同时获得，因为读操作本身是线程安全的，多个线程的读取操作不存在破坏数据的情况。而写锁则是互斥锁（不然就会发生本文说到的情况），不允许多个线程同时获得写锁。
  • 写操作和读操作也是互斥的。
  • Java的并发就含有读写锁ReadWriteLock。在多线程场景中，如果某个对象处于改变状态，可以用写锁加锁，这样所有做读操作对象的线程，在获取读锁时就会block住，直到写锁释放。

经典案例

小明小红小刚使用同一张银行卡卡号，在同一时间内进行频繁操作，一个频繁查看余额 ￥–>100 ￥–>99 ￥–>101 … ，有人一直存款2块 +2 +2 +2…，有人取钱取出1块 -1 -1 -1…，若是三个人都循环十次自己的操作，正常情况下最终余额应该是110，但如果充值和扣费是在两个线程同时进行，而且各算各的，再分别用自己的计算结果去覆盖余额，最终会导致计算不准确，结果余额不等110。

提问！

为什么会出现不等于的情况？

提示：三个线程拼命抢夺资源，当A线程修改值之前B刚好拿到余额count 那么会发生什么有趣的事情呢？

不妨大胆思考一下此时的余额或者之后的余额会如何？
3
…
…
…
…
.
2
…
…
…
…
.
1
…
…
…
…
.
没错！！！
当A线程修改值之前B刚好拿到余额，
A不知道B拿到了count，
若A读取count=100，之后存入2块，余额102
B在取出1块之前读取到count=100，取出1块，余额99
如此就很明显看到问题所在

此处附上实验代码

package org.acme.LockDemo;

import io.quarkus.logging.Log;
import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class AccountBalanceService {

    // 账户余额，假设初始值为100
    int accountBalance = 100;

    /**
     * 查询余额
     * @return
     */
    public int get() {
        // 模拟耗时的操作
        try {
            Thread.sleep(80);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return accountBalance;
    }

    /**
     * 模拟充值操作
     * @param value
     * @throws InterruptedException
     */
    public void deposit(int value) {
        // 先将accountBalance的值存入tempValue变量
        int tempValue  = accountBalance;
        Log.infov("start deposit, balance [{0}], deposit value [{1}]", tempValue, value);

        // 模拟耗时的操作
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        tempValue += value;

        // 用tempValue的值覆盖accountBalance，
        accountBalance = tempValue;

        Log.infov("end deposit, balance [{0}]", tempValue);
    }

    /**
     * 模拟扣费操作
     * @param value
     * @throws InterruptedException
     */
    public void deduct(int value) {
        // 先将accountBalance的值存入tempValue变量
        int tempValue  = accountBalance;
        Log.infov("start deduct, balance [{0}], deposit value [{1}]", tempValue, value);

        // 模拟耗时的操作
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        tempValue -= value;

        // 用tempValue的值覆盖accountBalance
        accountBalance = tempValue;

        Log.infov("end deduct, balance [{0}]", tempValue);
    }
}

package org.acme.LockDemoTest;

import io.quarkus.logging.Log;
import io.quarkus.test.ju
nit.QuarkusTest;
import org.acme.LockDemo.AccountBalanceService;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import javax.inject.Inject;
import java.util.concurrent.CountDownLatch;

@QuarkusTest
public class LockTest {

    @Inject
    AccountBalanceService account;

    @Test
    public void test() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        int initValue = account.get();

        final int COUNT = 10;

        // 这是个只负责读取的线程，循环读10次，每读一次就等待50毫秒
        new Thread(() -> {

            for (int i=0;i<COUNT;i++) {
                // 读取账号余额
                Log.infov("current balance {0}", account.get());
            }

            latch.countDown();
        }).start();

        // 这是个充值的线程，循环充10次，每次存2元
        new Thread(() -> {
            for (int i=0;i<COUNT;i++) {
                account.deposit(2);
            }
            latch.countDown();
        }).start();

        // 这是个扣费的线程，循环扣10次，每取1元
        new Thread(() -> {
            for (int i=0;i<COUNT;i++) {
                account.deduct(1);
            }
            latch.countDown();
        }).start();

        latch.await();

        int finalValue = account.get();
        Log.infov("finally, current balance {0}", finalValue);
        Assertions.assertEquals(initValue + COUNT, finalValue);
    }
}
  • 上述代码中，有以下几点需要注意
  • 在主线程中新增了三个子线程，分别执行查询、充值、扣费的操作，可见deposit和deduct方法是并行执行的
  • 初始余额100，充值一共20元，扣费一共10元，因此最终正确结果应该是110元
  • 为了确保三个子线程全部执行完毕后主线程才退出，这里用了CountDownLatch，在执行latch.await()的时候主线程就开始等待了，等到三个子线程把各自的**latch.await()**都执行后，主线程才会继续执行
  • 最终会检查余额是否等于110
  • 最终结论，测试失败，不等于110

解决办法可以有：

  1. 用传统的synchronized关键字修饰三个方法
  2. java包的读写锁

这里使用Quarkus的@Lock解决

@Lock

只需要将@Lock注解注解到类、方法上即可，该注解类型有三种选择：读锁，写锁，无锁。
以下是Quarkus的@Lock注解源码

@InterceptorBinding
@Inherited
@Target(value = { TYPE, METHOD })
@Retention(value = RUNTIME)
public @interface Lock {

    /**
     * 
     * @return the type of the lock
     */
    @Nonbinding
    Type value() default Type.WRITE;

    /**
     * If it's not possible to acquire the lock in the given time a {@link LockException} is thrown.
     * 
     * @see java.util.concurrent.locks.Lock#tryLock(long, TimeUnit)
     * @return the wait time
     */
    @Nonbinding
    long time() default -1l;

    /**
     * 
     * @return the wait time unit
     */
    @Nonbinding
    TimeUnit unit() default TimeUnit.MILLISECONDS;

    public enum Type {
        /**
         * Acquires the read lock before the business method is invoked.
         */
        READ,
        /**
         * Acquires the write (exclusive) lock before the business method is invoked.
         */
        WRITE,
        /**
         * Acquires no lock.
         * <p>
         * This could be useful if you need to override the behavior defined by a class-level interceptor binding.
         */
        NONE
    }

}

那么如何使用呢？

  • 使用之前我们需要了解到，@Lock默认会为类的每一个方法添加写锁
  • Lock.Type.READ表示将get方法改为读锁，Lock.Type.NONE表示该方法方法没有锁

被修改的代码如下：

package org.acme.LockDemo;

import io.quarkus.logging.Log;
import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
@Lock
public class AccountBalanceService {
    /**
     * 查询余额
     * @return
     */
     @Lock(value=Lock.Type.READ)
    public int get() {
        // 模拟耗时的操作
        try {
            Thread.sleep(80);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return accountBalance;
    };
	// 。。。。。。。。
}

研究结论

  • 当deposit方法或者deduct方法被调用时，其他线程在调用deposit、deduct、get方法时都被阻塞了，必须等deposit执行完毕，它们才重新去抢锁
  • 当deposit方法或者deduct方法没有被调用时，get方法可以被调用，并且可以在多个线程同时调用

讨论

这个案例看起来很好玩，读写锁也很好用，那么性能上，读写锁可以在哪些场景上不能使用呢？

3
…
…
…
…
.
2
…
…
…
…
.
1
…
…
…
…
.

  • 从以上例子可以看出，读写锁看似十分安全，但是代价不小（当一个线程运行标注着写锁的方法时，其他线程都需处于等待状态，若是还有网络等延迟问题，该程序简直处于噩梦级别）
  • 在并发性能要求较高的场景下要慎用，可以考虑乐观锁等方式来降低等待代价**
._Rᴠᴇᴍɪʏ
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jpa mysql乐观锁_JPA @Lock(value = LockModeType.PESSIMISTIC_WRITE) 悲观锁防坑
weixin_42138716的博客
02-17 3416
前提：由于业务需要在entity Product已经实现了@version的乐观锁的基础上再加上了悲观锁的控制@Lock(value = LockModeType.PESSIMISTIC_WRITE)Product findByType(String type);详情描述：但是当进行多请求的并发测试的时候发现程序第一个抢占findByType的请求能正常上锁，其它并发请求也正常进入等待，可是当第一...
使用 @Lock 注解实现Spring JAP锁
Terry_Long的博客
01-09 1万+
JPA 2.0增加了6种新的锁模式，其中两个是乐观锁。JPA 2.0也允许悲观锁，并增加了3种悲观锁，第6种锁模式是无锁。  下面是新增的两个乐观锁模式：  1、OPTIMISTIC：它和READ锁模式相同，JPA 2.0仍然支持READ锁模式，但明确指出在新应用程序中推荐使用OPTIMISTIC。  2、OPTIMISTIC_FORCE_INCREMENT：它和WRITE锁模式
详解SpringMVC注解@initbinder解决类型转换问题
08-27
本篇文章主要介绍了详解SpringMVC注解@initbinder解决类型转换问题，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java注解如何基于Redission实现分布式锁
08-25
主要介绍了Java注解如何基于Redission实现分布式锁,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java注解@Transactional事务类内调用不生效问题及解决办法
08-19
主要介绍了Java注解@Transactional事务类内调用不生效问题及解决办法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
关于Spring注解@Async引发其他注解失效的解决
08-27
主要介绍了关于Spring注解@Async引发其他注解失效的解决，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
自定义注解、lock、aop实现注解锁
l1394049664的博客
11-13 3114
1、自定义的锁注解 @Target({ElementType.PARAMETER, ElementType.METHOD})     @Retention(RetentionPolicy.RUNTIME)     @Documented     public  @interface Servicelock {       String description()  default ""; } ...
Lock锁详解
weixin_52385232的博客
07-10 636
Lock锁详解
redisson-spring-boot-starter
热门推荐
a1058926697的博客
05-11 1万+
redisson-spring-boot-starter spring boot 配置: spring.redis.redisson.config: classpath:redisson-beta.yml 或者 spring.redis.redisson.config: classpath:redisson-product.yml 配置类:org.redisson.spring.starter.RedissonAutoConfiguration 目前有很多项目还在使用jedis的set...
Lock的简单介绍
wo_wo_wo1的博客
07-19 326
Lock 索引 Lock 是 java.util.concurrent.locks包下的一个接口 ，包含了lock() 方法和unlock()方法等,lock() 用于获取锁资源,而unlock()用于释放锁资源。下面讲一下他的一些实现类。 ReentrantLock ReentrantLock 实现了Lock接口，是一种可重入锁。可重入锁可以理解为一种锁的标识。初始标识为0，表示当前锁没有...
Spring注解@Conditional案例解析
08-25
主要介绍了Spring注解@Conditional案例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
锁（lock）相关知识总结
FC_BarceIona的博客
02-01 869
概述： 锁机制在维护数据库并发性和一致性中扮演重要的角色，它可以防止错误的数据修改或错误的数据结构调整。 锁，死锁，阻塞是三个既独立又有关联的概念，会话持有锁时，只有其他会话也想访问相同的锁资源时，才可能产生阻塞（某些情况下并不阻塞，例如DML操作并不阻塞查询），所以有锁是正常的，有阻塞才会影响业务，平常说的“被锁了”，绝大多数是指存在阻塞现象。死锁是指两个或更多会话互相阻塞对方，
Java多线程-简单使用Lock(锁)
见证自己学习,成长的记录
09-07 3668
lock是JUC(并发)下的一个接口,一般用它的实现类ReentrantLock(可重入锁)比较多。加锁:lock(),解锁:unLock(),一般放在try catch finally中使用。Lock锁>同步代码块(已经进入了方法体,分配了相应资源)>同步方法(在方法体外)
@RedisLock注解实现分布式锁
qq_33816292的博客
08-15 3386
@RedisLock注解实现分布式锁
Spring Boot2+JPA之悲观锁和乐观锁实战
★【World Of Moshow 郑锴】★
11-15 3847
什么时候用悲观锁或者乐观锁: 1. `悲观锁`适合`写多读少`的场景。因为在使用的时候该线程会独占这个资源，就适合用悲观锁，否则用户只是浏览文章的话，用悲观锁就会经常加锁，增加了加锁解锁的资源消耗。 2.`乐观锁`适合`写少读多`的场景。由于乐观锁在发生冲突的时候会回滚或者重试，如果写的请求量很大的话，就经常发生冲突，结合事务会有经常的回滚和重试，这样对系统资源消耗也是非常大。
JAVA注释解析
m0_50132136的博客
03-01 356
`@NotNull`注解用于标记一个方法的参数或返回值，表示该参数或返回值不能为null，否则会抛出`NullPointerException`异常。@Lock4j,这是一个Java锁定注解，它可以用来锁定一个特定的项目，以便在操作过程中保持它的完整性。
Java分布式锁lock-spring-boot-starter的应用
yizhi鬼的专栏
05-09 1716
lock-spring-boot-starter是一个基于Spring Boot的starter机制编写的分布式锁工具。 与其他分布式锁不同的是,使用起来更方便快捷,只需要通过注解@Lock的方式即可实现对方法进行加锁。 官网地址：http://tooleek.gitee.io/lock-spring-boot-starter/ 支持的锁类型 可重入锁、公平锁、联锁、红锁、读锁、写锁 入门...
通过注解的方式实现分布式锁
码眼的博客
10-27 349
注解 /** * 锁 */ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Lock { /** * 锁定key 业务键 */ String[] lockKey() default LOCK_KEY; /** * 获取锁失败报错信息 */ String errorMsg() defa
@async注解java使用案例
最新发布
04-24
@Async注解在Java中的使用案例可以是在进行异步方法调用时使用。当我们在一个方法上添加@Async注解时，方法的调用就会被异步执行，也就是说它会在一个新的线程中执行而不会阻塞当前线程。 下面是一个简单的例子，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值