使用 @Lock 注解实现Spring JAP锁

骑猪看日落 2021-09-14 19:32 658阅读 0赞

[http://blog.csdn.net/terry\_long/article/details/54291455][http_blog.csdn.net_terry_long_article_details_54291455]

JPA 2.0增加了6种新的锁模式，其中两个是乐观锁。JPA 2.0也允许悲观锁，并增加了3种悲观锁，第6种锁模式是无锁。

下面是新增的两个乐观锁模式：

1、OPTIMISTIC：它和READ锁模式相同，JPA 2.0仍然支持READ锁模式，但明确指出在新应用程序中推荐使用OPTIMISTIC。

2、OPTIMISTIC\_FORCE\_INCREMENT：它和WRITE锁模式相同，JPA 2.0仍然支持WRITE锁模式，但明确指出在新应用程序中推荐使用OPTIMISTIC\_FORCE\_INCREMENT。

下面是新增的三个悲观锁模式：

1、PESSIMISTIC\_READ：只要事务读实体，实体管理器就锁定实体，直到事务完成锁才会解开，当你想使用重复读语义查询数据时使用这种锁模式，换句话说就是，当你想确保数据在连续读期间不被修改，这种锁模式不会阻碍其它事务读取数据。

2、PESSIMISTIC\_WRITE：只要事务更新实体，实体管理器就会锁定实体，这种锁模式强制尝试修改实体数据的事务串行化，当多个并发更新事务出现更新失败几率较高时使用这种锁模式。

3、PESSIMISTIC\_FORCE\_INCREMENT：当事务读实体时，实体管理器就锁定实体，当事务结束时会增加实体的版本属性，即使实体没有修改。

最后一种是NONE,也就是无锁。

可以通过@Lock注解来进行锁模式的指定，我们来看一下@Lock 注解源码：

\[java\] [ view plain][view plain] [ copy][view plain]

1.  @Target(\{ ElementType.METHOD, ElementType.ANNOTATION\_TYPE \})  
2.  @Retention(RetentionPolicy.RUNTIME)  
3.  @Documented  
4.  public @interface Lock \{  
5.    
6.      /\*\* 
7.       \* The \{@link LockModeType\} to be used when executing the annotated query or CRUD method. 
8.       \*  
9.       \* @return 
10.      \*/  
11.     LockModeType value();  
12. \}

LockModeType就是指定所模式的枚举了，看一下它的 的源码：

\[java\] [ view plain][view plain] [ copy][view plain]

1.  public enum LockModeType \{  
2.      /\*\* 
3.       \*  Synonymous with <code>OPTIMISTIC</code>. 
4.       \*  <code>OPTIMISTIC</code> is to be preferred for new 
5.       \*  applications. 
6.       \* 
7.       \*/  
8.      READ,  
9.    
10.     /\*\* 
11.      \*  Synonymous with <code>OPTIMISTIC\_FORCE\_INCREMENT</code>. 
12.      \*  <code>OPTIMISTIC\_FORCE\_IMCREMENT</code> is to be preferred for new 
13.      \*  applications. 
14.      \* 
15.      \*/  
16.     WRITE,  
17.   
18.     /\*\* 
19.      \* Optimistic lock. 
20.      \* 
21.      \* @since Java Persistence 2.0 
22.      \*/  
23.     OPTIMISTIC,  
24.   
25.     /\*\* 
26.      \* Optimistic lock, with version update. 
27.      \* 
28.      \* @since Java Persistence 2.0 
29.      \*/  
30.     OPTIMISTIC\_FORCE\_INCREMENT,  
31.   
32.     /\*\* 
33.      \* 
34.      \* Pessimistic read lock. 
35.      \* 
36.      \* @since Java Persistence 2.0 
37.      \*/  
38.     PESSIMISTIC\_READ,  
39.   
40.     /\*\* 
41.      \* Pessimistic write lock. 
42.      \* 
43.      \* @since Java Persistence 2.0 
44.      \*/  
45.     PESSIMISTIC\_WRITE,  
46.   
47.     /\*\* 
48.      \* Pessimistic write lock, with version update. 
49.      \* 
50.      \* @since Java Persistence 2.0 
51.      \*/  
52.     PESSIMISTIC\_FORCE\_INCREMENT,  
53.   
54.     /\*\* 
55.      \* No lock. 
56.      \* 
57.      \* @since Java Persistence 2.0 
58.      \*/  
59.     NONE  
60. \}

来写一个简单的例子（不完全代码）：

@Lock注解需要添加在Repository 层，也就是Hibernate的DAO层，如下：

\[java\] [ view plain][view plain] [ copy][view plain]

1.  public interface TestRepository extends  
2.          JpaRepository<TestObject, String>,  
3.          JpaSpecificationExecutor<TestObject> \{  
4.    
5.      @Lock(value = LockModeType.PESSIMISTIC\_READ)  
6.      @Query(value = "select o from TestObject where o.id= :id ")  
7.      public TestObject getByIdForUpdate(@Param("id") long id);  
8.    
9.  \}

这里用到了@Query 注解，只需要定义接口就可以了，spring会根据注解里的HQL语句自动生成实现。

对Repository的调用一般放在service层，调用方法必须被事务包裹，不然启动会报错。

\[java\] [ view plain][view plain] [ copy][view plain]

1.  public interface MyTestService\{  
2.  /\*\* 
3.  \* 定义接口 
4.  \*/  
5.  public TestObject updateObjStatus(long id,String status);  
6.  \}  
7.    
8.  public class MyTestServiceImpl\{  
9.  @Autowired  
10. private TestRepository repos;  
11.   
12. /\*\* 
13. \* 实现一个带锁的更新方法 
14. \*/  
15. @Transactional  
16. @Override  
17. public TestObject updateObjStatus(long id,String status)\{  
18. TestObject  obj = repos.getByIdForUpdate(id);  
19. if(null == obj )\{  
20. throw new RuntimeException("TestObject id = "\+id+",not found！");  
21. \}  
22. if(status.equals(obj.getStatus()))\{  
23. throw new RuntimeException("TestObject id = "\+id+",status is alread be："\+status+",update fail!");  
24. \}  
25. obj.setStatus(status);  
26. repos.save(obj);  
27.   
28. \}  
29. \}

在上面的例子中，我们尝试更新TestObject 对象的status，更新之前先将数据查询出来加上行级锁，确保某个线程在更新之时数据不会被其他线程修改掉，更新之前也进行判断，如果发现数据已被更新就跑出去异常结束更新。这样在多个线程同时对TestObject 对象进行更新时，最终只有一个线程会更新成功。

[http_blog.csdn.net_terry_long_article_details_54291455]: http://blog.csdn.net/terry_long/article/details/54291455
[view plain]: http://blog.csdn.net/terry_long/article/details/54291455#