spring注解@Transactional 和乐观锁,悲观锁并发问题

Posted 海绵般汲取

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了spring注解@Transactional 和乐观锁,悲观锁并发问题相关的知识,希望对你有一定的参考价值。

 

需求:系统中有一个自增的合同编号,在满足并发情况下,生成的合同编号是自增的。

测试工具:Apache Jmeter

实现方法:

创建一个数据库表。编号最大值记录表

表结构类似

CREATE TABLE `project_number_record` (
  `id` varchar(64) NOT NULL,
  `record_year` date DEFAULT NULL COMMENT \'记录年份\',
  `max_value` int(11) DEFAULT NULL COMMENT \'年份最大编号\',
  `status` char(1) NOT NULL DEFAULT \'0\' COMMENT \'状态(0正常 1删除 2停用)\',
  `create_by` varchar(64) NOT NULL COMMENT \'创建者\',
  `create_date` datetime NOT NULL COMMENT \'创建时间\',
  `update_by` varchar(64) NOT NULL COMMENT \'更新者\',
  `update_date` datetime NOT NULL COMMENT \'更新时间\',
  `remarks` varchar(500) DEFAULT NULL COMMENT \'备注信息\',
  `bus_type` varchar(64) DEFAULT \'\' COMMENT \'业务类型(合同,项目)\',
  `version` varchar(20) DEFAULT \'0\' COMMENT \'并发数据控制字段,时间戳数值\',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT=\'部门项目编号表\';

尝试使用过3种方法进行解决这个问题。

序号有序尝试方式:
1、使用@Transaction(readyOnly=false)+synchronized (this){}代码块的方式保证合同编号有序
2、synchronized (this){} 锁住 调用事务方法的代码
3、使用乐观锁保证合同编号有序(事务情况下执行需要考虑事务隔离级别问题)

 

 

 

1、使用@Transaction(readyOnly=false)+synchronized (this){}代码块的方式保证合同编号有序

遇到一个问题,在事务方法内使用同步代码块  synchronized (this){}

这种情况下,类代码如下。

@Transactional(readOnly = false)
    public String generateContractNo(Contract contract) {
        String uniqueOfficeCode="uniqueCode";
        String uniqueOfficeName="uniqueName";
        String numberStr = "0000";
        ProjectNumberRecord projectNumberRecord = new ProjectNumberRecord();
        projectNumberRecord.setOfficeCode(uniqueOfficeCode); //contract.getOfficeCode()
        projectNumberRecord.setBusType(ProjectNumberRecord.BUS_TYPE_CONTRACT);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        int year = calendar.get(Calendar.YEAR);
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        projectNumberRecord.setRecordYear(calendar.getTime());//事务和同步锁同时存在导致同步锁失效
        synchronized (this){
            String updateTimeStamp="";
            //获取当前年份的数据记录
            List<ProjectNumberRecord> projectNumberRecordList = projectNumberRecordService.findList(projectNumberRecord);
            ProjectNumberRecord dbProjectNumberRecord = null;
            if (projectNumberRecordList!=null && projectNumberRecordList.size() >= 1) {
                dbProjectNumberRecord = projectNumberRecordList.get(0);
            } else {
                //不存在,新增对应的数据
            }
            int maxValue = dbProjectNumberRecord.getMaxValue() + 1;
            dbProjectNumberRecord.setMaxValue(maxValue);
            numberStr = numberStr.substring(String.valueOf(maxValue).length()) + maxValue;

            // 在更新数据之前判断是否存在数据
            if(dbProjectNumberRecord.getIsNewRecord()){
                //新数据
                projectNumberRecordService.insert(dbProjectNumberRecord);
            }else{
                // 更新最大值数据
                dbProjectNumberRecord.setVersion(String.valueOf(System.currentTimeMillis()));
                long updateStatus = projectNumberRecordDao.updateNumberRecord(dbProjectNumberRecord);
            }
        }
        return numberStr;
    }

测试结果,10个线程并发产生的同样的合同编号,然后数据库会生成10条相同的数据。结果不符合要求,

 

 

 失败原因:

Synchronized 失效关键原因:是因为**Synchronized**锁定的是当前调用方法对象,而Spring AOP 处理事务会进行生成一个代理对象,并在代理对象执行方法前的事务开启,方法执行完的事务提交,所以说,事务的开启和提交并不是在 Synchronized 锁定的范围内。出现同步锁失效的原因是:当A(线程) 执行完getSn()方法,会进行释放同步锁,去做提交事务,但在A(线程)还没有提交完事务之前,B(线程)进行执行getSn() 方法,执行完毕之后和A(线程)一起提交事务, 这时候就会出现线程安全问题。

同步锁,锁的是代理对象,锁的对象不同,所以导致同步锁失效。

实际执行顺序线程是同时执行了。

A(线程): Spring begins transactional > 方法> Spring commits transactional
B(线程): Spring begins transactional > 方法> Spring commits transactional
原文链接:https://blog.csdn.net/prin_at/article/details/90671332

2、synchronized (this){} 锁住 调用事务方法的代码

 代码如下:

@RequestMapping(value = "testGenerateContractNo")
    @ResponseBody
    public ReturnObject testGenerateContractNo() {
        Contract contract=new Contract();
        contract.setId("1241525874512580608");
        logger.info("对象哈希编码:"+outSideService.hashCode());
        String contractNo;
        synchronized (contractService){
            contractNo = outSideService.generateContractNo(contract);
        }

        return ReturnObject.success(contractNo);
    }

执行结果:10个线程并发下,生成的合同编号是有序的。可能会存在执行效率慢的问题,因为这是单线程操作。

3、使用乐观锁保证合同编号有序(事务情况下执行需要考虑事务隔离级别问题)

@Transactional(readOnly = false)
    public String generateContractNo(Contract contract) {
        String uniqueOfficeCode="uniqueCode";
        String uniqueOfficeName="uniqueName";
        String numberStr = "0000";
        ProjectNumberRecord projectNumberRecord = new ProjectNumberRecord();
        projectNumberRecord.setOfficeCode(uniqueOfficeCode); //contract.getOfficeCode()
        projectNumberRecord.setBusType(ProjectNumberRecord.BUS_TYPE_CONTRACT);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        int year = calendar.get(Calendar.YEAR);
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        projectNumberRecord.setRecordYear(calendar.getTime());
        //使用乐观锁,使用更新时间字段来判断数据是否被更新,如果被更新则线程休眠0.2秒
        while(true){
            String updateTimeStamp="";
            //获取当前年份的数据记录
            List<ProjectNumberRecord> projectNumberRecordList = projectNumberRecordService.findList(projectNumberRecord);
            ProjectNumberRecord dbProjectNumberRecord = null;
            if (projectNumberRecordList!=null && projectNumberRecordList.size() >= 1) {
                dbProjectNumberRecord = projectNumberRecordList.get(0);
                updateTimeStamp=dbProjectNumberRecord.getVersion();
                dbProjectNumberRecord.setOldVersion(updateTimeStamp);
            } else {
                //不存在,新增部门对应的数据
            }
            int maxValue = dbProjectNumberRecord.getMaxValue() + 1;
            dbProjectNumberRecord.setMaxValue(maxValue);
            numberStr = numberStr.substring(String.valueOf(maxValue).length()) + maxValue;

            // 在更新数据之前判断是否存在数据
            if(dbProjectNumberRecord.getIsNewRecord()){
                //新数据
                projectNumberRecordService.insert(dbProjectNumberRecord);
                break;
            }else{
                // 更新最大值数据
                dbProjectNumberRecord.setVersion(String.valueOf(System.currentTimeMillis()));
                long updateStatus = projectNumberRecordDao.updateNumberRecord(dbProjectNumberRecord);

                if(updateStatus>0){
                    // 更新成功,没有其他线程更新过数据
                    logger.info("更新成功,没有其他线程更新过数据");
                    break;
                }else{
                    logger.info("更新失败,休眠1秒");
                    numberStr="0000";
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return numberStr;
    }

 

 结果:只有第一个抢占的线程才可以正常获取合同编号,其他9个线程一致在做循环显示更新失败。

原因是因为,spring事务的隔离级别默认是  Isolation.DEFAULT:为数据源的默认隔离级别。大多数的数据库隔离级别:read committed 读取提交内容,第一个线程的事务更新的这条数据,然后事务还没有提交,导致其他线程读取的version数据不正确,就一直更新失败,死循环。

当设置数据库隔离级别为:

@Transactional(readOnly = false,isolation = Isolation.READ_UNCOMMITTED)

isolation = Isolation.READ_UNCOMMITTED读事务允许其他读事务和写事务,未提交的写事务

修改完后:结果合同编号有序。

还有一种方式:去掉@Transactionl注解,乐观锁也可以正常执行

 

以上是关于spring注解@Transactional 和乐观锁,悲观锁并发问题的主要内容,如果未能解决你的问题,请参考以下文章

Spring @Transactional 和 Spring @Lock 注解有啥关系?

Spring 事务注解@Transactional

Spring——事务注解@Transactional建议收藏

Spring之Transactional注解

spring @Transactional注解参数详解

spring @Transactional注解参数详解(13)