mybatis和JPA实现乐观锁解决并发问题-阿里巴巴JAVA开发手册详细解读

2019年3月10日 215次阅读 来源: java锁

在阿里巴巴近期发出的阿里巴巴JAVA开发手册（终极版）中有这样一条记录。

【强制】并发修改同一记录时，避免更新丢失，需要加锁。要么在应用层加锁，要么在缓存加锁，要么在数据库层使用乐观锁，使用version作为更新依据。

说明：如果每次访问冲突概率小于20%，推荐使用乐观锁，否则使用悲观锁。乐观锁的重试次数不得小于3次。

那么什么是乐观锁呢？

乐观锁（ Optimistic Locking ） 相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。那么我们如何实现乐观锁呢，一般来说有以下2种方式：

1.使用数据版本（Version）记录机制实现，这是乐观锁最常用的一种实现方式。何谓数据版本？即为数据增加一个版本标识，一般是通过为数据库表增加一个数字类型的 “version” 字段来实现。当读取数据时，将version字段的值一同读出，数据每更新一次，对此version值加一。当我们提交更新的时候，判断数据库表对应记录的当前版本信息与第一次取出来的version值进行比对，如果数据库表当前版本号与第一次取出来的version值相等，则予以更新，否则认为是过期数据。

通过实例让大家详细理解

银行两操作员同时操作同一账户就是典型的例子。
比如A、B操作员同时读取一余额为1000元的账户，A操作员为该账户增加100元，B操作员同时为该账户扣除50元，A先提交，B后提交。最后实际账户余额为1000-50=950元，但本该为1000+100-50=1050。这就是典型的并发问题。

对于上面修改用户帐户信息的例子而言，假设数据库中帐户信息表中有一个version字段，当前值为1；而当前帐户余额字段(balance)为1000元。假设操作员A先更新完，操作员B后更新。
a、操作员A此时将其读出(version=1)，并从其帐户余额中增加100(1000+100=1100)。
b、在操作员A操作的过程中，操作员B也读入此用户信息(version=1)，并从其帐户余额中扣除50(1000-50=950)。
c、操作员A完成了修改工作，将数据版本号加一(version=2)，连同帐户增加后余额(balance=1100)，提交至数据库更新，此时由于提交数据版本大于数据库记录当前版本，数据被更新，数据库记录version更新为2。
d、操作员B完成了操作，也将版本号加一(version=2)试图向数据库提交数据(balance=950)，但此时比对数据库记录版本时发现，操作员B提交的数据版本号为2，数据库记录当前版本也为2，不满足 “提交版本必须大于记录当前版本才能执行更新 “的乐观锁策略，因此，操作员B的提交被驳回。
这样，就避免了操作员B用基于version=1的旧数据修改的结果覆盖操作员A的操作结果的可能。

数据建表

t_goods表，增加一个version字段，数据默认version值为0。

t_goods表初始数据如下：

Sql代码  

  1. mysql> select * from t_goods;  
  2. +—-+——–+——+———+  
  3. | id | status | name | version |  
  4. +—-+——–+——+———+  
  5. |  1 |      1 | 道具 |       0 |  
  6. |  2 |      2 | 装备 |       1 |  
  7. +—-+——–+——+———+  
  8. 2 rows in set  
  9.  

mybatis实现

Goods实体类：

Java代码  

  1. /** 
  2.  * ClassName: Goods <br/> 
  3.  * Function: 商品实体. <br/> 
  4.  * date: 2013-5-8 上午09:16:19 <br/> 
  5.  * @author chenzhou1025@126.com 
  6.  */  
  7. public class Goods implements Serializable {  
  8.   
  9.     /** 
  10.      * serialVersionUID:序列化ID. 
  11.      */  
  12.     private static final long serialVersionUID = 6803791908148880587L;  
  13.       
  14.     /** 
  15.      * id:主键id. 
  16.      */  
  17.     private int id;  
  18.       
  19.     /** 
  20.      * status:商品状态：1未下单、2已下单. 
  21.      */  
  22.     private int status;  
  23.       
  24.     /** 
  25.      * name:商品名称. 
  26.      */  
  27.     private String name;  
  28.       
  29.     /** 
  30.      * version:商品数据版本号. 
  31.      */  
  32.     private int version;  
  33.       
  34.     @Override  
  35.     public String toString(){  
  36.         return “good id:”+id+“,goods status:”+status+“,goods name:”+name+“,goods version:”+version;  
  37.     }  
  38.   
  39.     //setter and getter  
  40.   
  41. }  

GoodsDao

Java代码  

  1. /** 
  2.  * updateGoodsUseCAS:使用CAS(Compare and set)更新商品信息. <br/> 
  3.  * 
  4.  * @author chenzhou1025@126.com 
  5.  * @param goods 商品对象 
  6.  * @return 影响的行数 
  7.  */  
  8. int updateGoodsUseCAS(Goods goods);  

mapper.xml

Xml代码  

  1. <update id=“updateGoodsUseCAS” parameterType=“Goods”>  
  2.     <![CDATA[ 
  3.         update t_goods 
  4.         set status=#{status},name=#{name},version=version+1 
  5.         where id=#{id} and version=#{version} 
  6.     ]]>  
  7. </update>  

GoodsDaoTest测试类

Java代码  

  1. @Test  
  2. public void goodsDaoTest(){  
  3.     int goodsId = 1;  
  4.     //根据相同的id查询出商品信息，赋给2个对象  
  5.     Goods goods1 = this.goodsDao.getGoodsById(goodsId);  
  6.     Goods goods2 = this.goodsDao.getGoodsById(goodsId);  
  7.       
  8.     //打印当前商品信息  
  9.     System.out.println(goods1);  
  10.     System.out.println(goods2);  
  11.       
  12.     //更新商品信息1  
  13.     goods1.setStatus(2);//修改status为2  
  14.     int updateResult1 = this.goodsDao.updateGoodsUseCAS(goods1);  
  15.     System.out.println(“修改商品信息1”+(updateResult1==1?“成功”:“失败”));  
  16.       
  17.     //更新商品信息2  
  18.     goods1.setStatus(2);//修改status为2  
  19.     int updateResult2 = this.goodsDao.updateGoodsUseCAS(goods1);  
  20.     System.out.println(“修改商品信息2”+(updateResult2==1?“成功”:“失败”));  
  21. }  

输出结果：

Shell代码  

  1. good id:1,goods status:1,goods name:道具,goods version:1  
  2. good id:1,goods status:1,goods name:道具,goods version:1  
  3. 修改商品信息1成功  
  4. 修改商品信息2失败  

说明：

在GoodsDaoTest测试方法中，我们同时查出同一个版本的数据，赋给不同的goods对象，然后先修改good1对象然后执行更新操作，执行成功。然后我们修改goods2，执行更新操作时提示操作失败。此时t_goods表中数据如下：

Sql代码  

  1. mysql> select * from t_goods;  
  2. +—-+——–+——+———+  
  3. | id | status | name | version |  
  4. +—-+——–+——+———+  
  5. |  1 |      2 | 道具 |       2 |  
  6. |  2 |      2 | 装备 |       2 |  
  7. +—-+——–+——+———+  
  8. 2 rows in set  
  9.   
  10. mysql>   

我们可以看到 id为1的数据version已经在第一次更新时修改为2了。所以我们更新good2时update where条件已经不匹配了，所以更新不会成功，具体sql如下：

Sql代码  

  1. update t_goods   
  2. set status=2,version=version+1  
  3. where id=#{id} and version=#{version};  

这样我们就在Mybatis实现了乐观锁

JPA实现

持久层使用jpa时比较简单，JPA默认提供了一个注解@Version，我们只需要在刚才的实体类中做相应的注解就可以。

Goods实体类：

Java代码  

  1. /** 
  2.  * ClassName: Goods <br/> 
  3.  * Function: 商品实体. <br/> 
  4.  * date: 2013-5-8 上午09:16:19 <br/> 
  5.  * @author chenzhou1025@126.com 
  6.  */  
  7. public class Goods implements Serializable {  
  8.   
  9.     /** 
  10.      * serialVersionUID:序列化ID. 
  11.      */  
  12.     private static final long serialVersionUID = 6803791908148880587L;  
  13.       
  14.     /** 
  15.      * id:主键id. 
  16.      */  
  17.   @Id
    @GenericGenerator(name = "PKUUID", strategy = "uuid2")
    @GeneratedValue(generator = "PKUUID")
    @Column(length = 36)
  18.     private Integer id;  
  19.       
  20.     /** 
  21.      * status:商品状态：1未下单、2已下单. 
  22.      */  
  23.  @Column(name = "status")
  24.     private Integer status;  
  25.       
  26.     /** 
  27.      * name:商品名称. 
  28.      */  
  29.  @Column(name = "name")
  30.     private String name;  
  31.       
  32.     /** 
  33.      * version:商品数据版本号. 
  34.      */  
  35.  @Version
  36.     private Integer version;  
  37.       
  38.     @Override  
  39.     public String toString(){  
  40.         return “good id:”+id+“,goods status:”+status+“,goods name:”+name+“,goods version:”+version;  
  41.     }  
  42.   
  43.     //setter and getter  
  44.   
  45. }  

在JPA中对于添加了@Version注解的字段，我们不需要像mybatis中一样手动去控制，每一次save操作会在原来的基础上+1，如果初始为null，则springdata自动设置其为0。

总结

乐观锁，用在一些敏感业务数据上，而其本身的修饰：乐观，代表的含义便是相信大多数场景下version是一致的。但是从业务角度出发又要保证数据的严格一致性，避免脏读等问题，使用的场景需要斟酌。记得前面一片博文简单介绍了一下行级锁的概念，其实本质上和乐观锁都是想要再数据库层面加锁控制并发，那么什么时候该用乐观锁，行级锁，什么时候得在程序级别加同步锁，又要根据具体的业务场景去判断。找到能够满足自己项目需求的方案，找到性能和可靠性的平衡点，才是一个程序员的价值所在。

欢迎大家关注、转载、评论。

大家有什么问题需要讨论的也欢迎在评论下留言，我会随时关注，大家一起进步。

参考博客地址：

http://www.cnblogs.com/linjiqin/p/5096206.html

http://chenzhou123520.iteye.com/blog/1863407

http://blog.csdn.net/u013815546/article/details/54784025

http://blog.csdn.net/tzdwsy/article/details/47976919

    原文作者：java锁
    原文地址: https://blog.csdn.net/yueaini10000/article/details/78131474
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞