基于 Spring Data JPA 聊聊悲观锁和乐观锁

举个场景：多线程、多进程应用在对数据库的同一数据进行非幂等操作时，如果没有添加相应的锁机制进行校验、判断，通常会导致数据的脏写。抛开分布式锁这种解决思路，简单的来讲，可以优先考虑从数据库层面去解决这个问题。

数据库锁分为乐观锁和悲观锁，前者适合读多写少的场景，后者适合读少写多的场景。乐观锁的实现通常是采用加版本号的形式，即如果更新时版本号未发生改变，则本次操作是成功的，且当前版本号的信息也相应会发生改变；再来看看悲观锁，悲观锁的实现方式是在待执行的SQL语句后加上for update，利用了数据库的行锁或是表锁特性来进行实现，但如果使用不当，会严重拖累整个操作的执行速度。

下面的实际案例展示了具体的操作，该项目基于 Spring Data JPA 实现：

1. 新建两个实体类，Teacher对应悲观锁的示例，User对应乐观锁示例：

/**
 * 悲观锁示例
 */
@Data
@Entity
@NoArgsConstructor
public class Teacher {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;

    public Teacher(String name) {
        this.name = name;
    }
}

/**
 * 乐观锁示例
 */
@Data
@Entity
@NoArgsConstructor
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;

    /**
     * 乐观锁实现方式①：直接添加@Version
     */
    @Version
    private Integer version = 0;

    public User(String name) {
        this.name = name;
    }
}

2. 乐观锁的实现有两种：

   • 2.1 实体类添加 version 字段并用相应的@Version进行标记，这种方式较为简单方便(如上User)；
   • 2.2 在进行更新操作的时候进行 version 判断，需要自己写 SQL 实现(如下)

   public interface UserRepository extends JpaRepository {
   
       /**
        * 乐观锁实现方式②：在SQL中添加版本号校验
        */
       @Modifying
       @Query(value = "update user u set u.name = ?2, u.version = u.version + 1 where u.id = ?1 and u.version = ?3", nativeQuery = true)
       int updateWithVersion(int id, String name, int version);
   
   }
   

3. 悲观锁的实现也有两种：

   • 3.1 添加@Lock注解，并设置值为LockModeType.PESSIMISTIC_WRITE即可代表行级锁，同样这种方式也容易操作

   public interface TeacherRepository extends JpaRepository {
   
       /**
        * 悲观锁实现①：使用@Lock注解，并且设置值为LockModeType.PESSIMISTIC_WRITE
        */
       @Override
       @Lock(value = LockModeType.PESSIMISTIC_WRITE)
       Optional findById(Integer id);
   
   }
   

   • 3.2 自行写 SQL 语句，然后结尾加上for update(如下)

   public interface TeacherRepository extends JpaRepository {
   
       /**
        * 悲观锁实现②：手写SQL，结尾加上for update
        */
       @Query(value = "select t.* from teacher t where t.id = ?1 for update", nativeQuery = true)
       Optional findTeacherForUpdate(int id);
   
   }
   

4. 编写测试用例：

@RunWith(SpringRunner.class)
@SpringBootTest
public class LockApplicationTests {

    @Resource
    private UserService userService;

    @Resource
    private TeacherService teacherService;

    @Test
    public void testUser() {
        // 新增数据
        User user = new User("Jared");
        User dbUser = userService.add(user);

        // @throws org.springframework.orm.ObjectOptimisticLockingFailureException

        // 乐观锁①：更新User
        new Thread(() -> userService.optimisticLock(dbUser, 500L)).start();
        userService.optimisticLock(dbUser, 1000L);

        // 乐观锁②：更新User
        new Thread(() -> userService.optimisticLock(dbUser, 1000L)).start();
        userService.optimisticLock2(dbUser, 500L);
    }

    @Test
    public void testTeacher() {
        // 新增数据
        Teacher teacher = new Teacher("Nancy");
        Teacher dbTeacher = teacherService.add(teacher);

        // 悲观锁①：更新Teacher
        new Thread(() -> {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            teacherService.pessimisticLock(dbTeacher, 200L);
        }).start();
        // Success
        teacherService.pessimisticLock(dbTeacher, 2000L);

        // 悲观锁②：更新Teacher
        new Thread(() -> {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            teacherService.pessimisticLock2(dbTeacher, 300L);
        }).start();
        // Success
        teacherService.pessimisticLock2(dbTeacher, 3000L);
    }

}

5. 最终结论

采用乐观锁，操作失败后会抛出ObjectOptimisticLockingFailureException;
使用悲观锁，上述两条操作里面，最终只有先获取到锁的那条操作可以成功执行。

参考链接

JPA之@Version进行乐观锁并发更新
JPA 各种实体锁模式的区别
聊聊数据库乐观锁和悲观锁，乐观锁失败后重试

示例源码

文章已授权转载，原文链接：基于 Spring Data JPA 聊聊悲观锁和乐观锁