提示:原网页已由神马搜索转码, 内容由www.jb51.net提供.

您的位置：首页→ 软件编程→ java→ SpringBoot整合MyBatis 乐观锁和悲观锁

SpringBoot整合MyBatis实现乐观锁和悲观锁的示例

更新时间：2019年09月20日 10:05:40 作者：浮云Cloud

这篇文章主要介绍了SpringBoot整合MyBatis实现乐观锁和悲观锁的示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

本文以转账操作为例，实现并测试乐观锁和悲观锁。

全部代码：https://github.com/imcloudfloating/Lock_Demo

GitHub Page：https://cloudli.top

死锁问题

当 A, B 两个账户同时向对方转账时，会出现如下情况：

时刻	事务 1 (A 向 B 转账)	事务 2 (B 向 A 转账)
T1	Lock A	Lock B
T2	Lock B (由于事务 2 已经 Lock A，等待)	Lock A (由于事务 1 已经 Lock B，等待)

由于两个事务都在等待对方释放锁，于是死锁产生了，解决方案：按照主键的大小来加锁，总是先锁主键较小或较大的那行数据。

建立数据表并插入数据（MySQL）

create table account
(
  id   int auto_increment
    primary key,
  deposit decimal(10, 2) default 0.00 not null,
  version int      default 0  not null
);
INSERT INTO vault.account (id, deposit, version) VALUES (1, 1000, 0);
INSERT INTO vault.account (id, deposit, version) VALUES (2, 1000, 0);
INSERT INTO vault.account (id, deposit, version) VALUES (3, 1000, 0);
INSERT INTO vault.account (id, deposit, version) VALUES (4, 1000, 0);
INSERT INTO vault.account (id, deposit, version) VALUES (5, 1000, 0);
INSERT INTO vault.account (id, deposit, version) VALUES (6, 1000, 0);
INSERT INTO vault.account (id, deposit, version) VALUES (7, 1000, 0);
INSERT INTO vault.account (id, deposit, version) VALUES (8, 1000, 0);
INSERT INTO vault.account (id, deposit, version) VALUES (9, 1000, 0);
INSERT INTO vault.account (id, deposit, version) VALUES (10, 1000, 0);

Mapper 文件

悲观锁使用 select ... for update，乐观锁使用 version 字段。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.cloud.demo.mapper.AccountMapper">
  <select id="selectById" resultType="com.cloud.demo.model.Account">
    select *
    from account
    where id = #{id}
  </select>
  <update id="updateDeposit" keyProperty="id" parameterType="com.cloud.demo.model.Account">
    update account
    set deposit=#{deposit},
      version = version + 1
    where id = #{id}
     and version = #{version}
  </update>
  <select id="selectByIdForUpdate" resultType="com.cloud.demo.model.Account">
    select *
    from account
    where id = #{id} for
    update
  </select>
  <update id="updateDepositPessimistic" keyProperty="id" parameterType="com.cloud.demo.model.Account">
    update account
    set deposit=#{deposit}
    where id = #{id}
  </update>
  <select id="getTotalDeposit" resultType="java.math.BigDecimal">
    select sum(deposit) from account;
  </select>
</mapper>

Mapper 接口

@Component
public interface AccountMapper {
  Account selectById(int id);
  Account selectByIdForUpdate(int id);
  int updateDepositWithVersion(Account account);
  void updateDeposit(Account account);
  BigDecimal getTotalDeposit();
}

Account POJO

@Data
public class Account {
  private int id;
  private BigDecimal deposit;
  private int version;
}

AccountService

在 transferOptimistic 方法上有个自定义注解 @Retry，这个用来实现乐观锁失败后重试。

@Slf4j
@Service
public class AccountService {
  public enum Result{
    SUCCESS,
    DEPOSIT_NOT_ENOUGH,
    FAILED,
  }
  @Resource
  private AccountMapper accountMapper;
  private BiPredicate<BigDecimal, BigDecimal> isDepositEnough = (deposit, value) -> deposit.compareTo(value) > 0;
  /**
   * 转账操作，悲观锁
   *
   * @param fromId 扣款账户
   * @param toId  收款账户
   * @param value 金额
   */
  @Transactional(isolation = Isolation.READ_COMMITTED)
  public Result transferPessimistic(int fromId, int toId, BigDecimal value) {
    Account from, to;
    try {
      // 先锁 id 较大的那行，避免死锁
      if (fromId > toId) {
        from = accountMapper.selectByIdForUpdate(fromId);
        to = accountMapper.selectByIdForUpdate(toId);
      } else {
        to = accountMapper.selectByIdForUpdate(toId);
        from = accountMapper.selectByIdForUpdate(fromId);
      }
    } catch (Exception e) {
      log.error(e.getMessage());
      TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
      return Result.FAILED;
    }
    if (!isDepositEnough.test(from.getDeposit(), value)) {
      TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
      log.info(String.format("Account %d is not enough.", fromId));
      return Result.DEPOSIT_NOT_ENOUGH;
    }
    from.setDeposit(from.getDeposit().subtract(value));
    to.setDeposit(to.getDeposit().add(value));
    accountMapper.updateDeposit(from);
    accountMapper.updateDeposit(to);
    return Result.SUCCESS;
  }
  /**
   * 转账操作，乐观锁
   * @param fromId 扣款账户
   * @param toId  收款账户
   * @param value 金额
   */
  @Retry
  @Transactional(isolation = Isolation.REPEATABLE_READ)
  public Result transferOptimistic(int fromId, int toId, BigDecimal value) {
    Account from = accountMapper.selectById(fromId),
        to = accountMapper.selectById(toId);
    if (!isDepositEnough.test(from.getDeposit(), value)) {
      TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
      return Result.DEPOSIT_NOT_ENOUGH;
    }
    from.setDeposit(from.getDeposit().subtract(value));
    to.setDeposit(to.getDeposit().add(value));
    int r1, r2;
    // 先锁 id 较大的那行，避免死锁
    if (from.getId() > to.getId()) {
      r1 = accountMapper.updateDepositWithVersion(from);
      r2 = accountMapper.updateDepositWithVersion(to);
    } else {
      r2 = accountMapper.updateDepositWithVersion(to);
      r1 = accountMapper.updateDepositWithVersion(from);
    }
    if (r1 < 1 || r2 < 1) {
      // 失败，抛出重试异常，执行重试
      throw new RetryException("Transfer failed, retry.");
    } else {
      return Result.SUCCESS;
    }
  }
}

使用 Spring AOP 实现乐观锁失败后重试

自定义注解 Retry

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Retry {
  int value() default 3; // 重试次数
}

重试异常 RetryException

public class RetryException extends RuntimeException {
  public RetryException(String message) {
    super(message);
  }
}

重试的切面类

tryAgain 方法使用了 @Around 注解（表示环绕通知），可以决定目标方法在何时执行，或者不执行，以及自定义返回结果。这里首先通过 ProceedingJoinPoint.proceed() 方法执行目标方法，如果抛出了重试异常，那么重新执行直到满三次，三次都不成功则回滚并返回 FAILED。

@Slf4j
@Aspect
@Component
public class RetryAspect {
  @Pointcut("@annotation(com.cloud.demo.annotation.Retry)")
  public void retryPointcut() {
  }
  @Around("retryPointcut() && @annotation(retry)")
  @Transactional(isolation = Isolation.READ_COMMITTED)
  public Object tryAgain(ProceedingJoinPoint joinPoint, Retry retry) throws Throwable {
    int count = 0;
    do {
      count++;
      try {
        return joinPoint.proceed();
      } catch (RetryException e) {
        if (count > retry.value()) {
          log.error("Retry failed!");
          TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
          return AccountService.Result.FAILED;
        }
      }
    } while (true);
  }
}

单元测试

用多个线程模拟并发转账，经过测试，悲观锁除了账户余额不足，或者数据库连接不够以及等待超时，全部成功；乐观锁即使加了重试，成功的线程也很少，500 个平均也就十几个成功。

所以对于写多读少的操作，使用悲观锁，对于读多写少的操作，可以使用乐观锁。

完整代码请见 Github：https://github.com/imcloudfloating/Lock_Demo。

@Slf4j
@SpringBootTest
@RunWith(SpringRunner.class)
class AccountServiceTest {
  // 并发数
  private static final int COUNT = 500;
  @Resource
  AccountMapper accountMapper;
  @Resource
  AccountService accountService;
  private CountDownLatch latch = new CountDownLatch(COUNT);
  private List<Thread> transferThreads = new ArrayList<>();
  private List<Pair<Integer, Integer>> transferAccounts = new ArrayList<>();
  @BeforeEach
  void setUp() {
    Random random = new Random(currentTimeMillis());
    transferThreads.clear();
    transferAccounts.clear();
    for (int i = 0; i < COUNT; i++) {
      int from = random.nextInt(10) + 1;
      int to;
      do{
        to = random.nextInt(10) + 1;
      } while (from == to);
      transferAccounts.add(new Pair<>(from, to));
    }
  }
  /**
   * 测试悲观锁
   */
  @Test
  void transferByPessimisticLock() throws Throwable {
    for (int i = 0; i < COUNT; i++) {
      transferThreads.add(new Transfer(i, true));
    }
    for (Thread t : transferThreads) {
      t.start();
    }
    latch.await();
    Assertions.assertEquals(accountMapper.getTotalDeposit(),
        BigDecimal.valueOf(10000).setScale(2, RoundingMode.HALF_UP));
  }
  /**
   * 测试乐观锁
   */
  @Test
  void transferByOptimisticLock() throws Throwable {
    for (int i = 0; i < COUNT; i++) {
      transferThreads.add(new Transfer(i, false));
    }
    for (Thread t : transferThreads) {
      t.start();
    }
    latch.await();
    Assertions.assertEquals(accountMapper.getTotalDeposit(),
        BigDecimal.valueOf(10000).setScale(2, RoundingMode.HALF_UP));
  }
  /**
   * 转账线程
   */
  class Transfer extends Thread {
    int index;
    boolean isPessimistic;
    Transfer(int i, boolean b) {
      index = i;
      isPessimistic = b;
    }
    @Override
    public void run() {
      BigDecimal value = BigDecimal.valueOf(
          new Random(currentTimeMillis()).nextFloat() * 100
      ).setScale(2, RoundingMode.HALF_UP);
      AccountService.Result result = AccountService.Result.FAILED;
      int fromId = transferAccounts.get(index).getKey(),
          toId = transferAccounts.get(index).getValue();
      try {
        if (isPessimistic) {
          result = accountService.transferPessimistic(fromId, toId, value);
        } else {
          result = accountService.transferOptimistic(fromId, toId, value);
        }
      } catch (Exception e) {
        log.error(e.getMessage());
      } finally {
        if (result == AccountService.Result.SUCCESS) {
          log.info(String.format("Transfer %f from %d to %d success", value, fromId, toId));
        }
        latch.countDown();
      }
    }
  }
}

MySQL 配置

innodb_rollback_on_timeout='ON'
max_connections=1000
innodb_lock_wait_timeout=500

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

Mybatis-Plus乐观锁配置流程

SpringBoot+MyBatisPlus中乐观锁的实现示例

MyBatisPlus+SpringBoot实现乐观锁功能详细流程

MyBatis-Plus乐观锁插件的用法小结

mybatis plus乐观锁及实现详解

浅谈Mybatis乐观锁插件

Mybatis Generator Plugin悲观锁实现示例

MyBatis实现乐观锁和悲观锁的示例代码

java二叉树的数据插入算法介绍

大家好，本篇文章主要讲的是java二叉树的数据插入算法介绍，感兴趣的同学赶快来看一看吧，对你有帮助的话记得收藏一下，方便下次浏览

2021-12-12
Java最简洁数据结构之冒泡排序快速理解

冒泡排序是编程中数据结构绕不过的一个基础点，有关于冒泡排序的文章也有很多，但可能会比较缭乱未能理解，本章将一子u为简洁明了的例图带你通关冒泡排序

2021-11-11
详解Java中布隆过滤器(Bloom Filter)原理及其使用场景

布隆过滤器是1970年由布隆提出的，它实际上是一个很长的二进制向量和一系列随机映射函数，它的作用是检索一个元素是否存在我们的集合之中，本文给大家详细的讲解一下布隆过滤器，感兴趣的同学可以参考阅读

2023-05-05
Java的CGLIB动态代理深入解析

这篇文章主要介绍了Java的CGLIB动态代理深入解析,CGLIB是强大的、高性能的代码生成库,被广泛应用于AOP框架,它底层使用ASM来操作字节码生成新的类,为对象引入间接级别,以控制对象的访问,需要的朋友可以参考下

2023-11-11
java自带命令行工具jmap、jhat与jinfo的使用实例代码详解

本篇文章主要通过代码实例对java自带命令行工具jmap、jhat与jinfo的使用做出了详解，需要的朋友可以参考下

2017-04-04
Spring-webflux访问关系型数据库实战

这篇文章主要为大家介绍了Spring-webflux访问关系型数据库实战详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

2023-07-07
Java定时器Timer使用方法详解

这篇文章主要为大家详细介绍了Java定时器Timer的使用方法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

2017-12-12
Spring Boot配置线程池拒绝策略的场景分析(妥善处理好溢出的任务)

本文通过实例代码给大家介绍下如何为线程池配置拒绝策略、如何自定义拒绝策略。对Spring Boot配置线程池拒绝策略的相关知识感兴趣的朋友一起看看吧

2021-09-09
Java Spring Boot实战练习之单元测试篇

单元测试(unit testing)，是指对软件中的最小可测试单元进行检查和验证。对于单元测试中单元的含义，一般来说，要根据实际情况去判定其具体含义，如C语言中单元指一个函数，Java里单元指一个类，图形化的软件中可以指一个窗口或一个菜单等

2021-10-10
java split结果去除空字符串的方法实现

在Java开发中,我们经常需要对字符串进行分割操作,本文主要介绍了java split结果去除空字符串的方法实现,具有一定的参考价值,感兴趣的可以了解一下

2023-10-10

脚本之家

SpringBoot整合MyBatis实现乐观锁和悲观锁的示例

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具