举个场景：多线程、多进程应用在对数据库的同一数据进行非幂等操作时，如果没有添加相应的锁机制进行校验、判断，通常会导致数据的脏写。抛开分布式锁这种解决思路，简单的来讲，可以优先考虑从数据库层面去解决这个问题。
数据库锁分为乐观锁和悲观锁，前者适合读多写少的场景，后者适合读少写多的场景。乐观锁的实现通常是采用加版本号的形式，即如果更新时版本号未发生改变，则本次操作是成功的，且当前版本号的信息也相应会发生改变；再来看看悲观锁，悲观锁的实现方式是在待执行的SQL语句后加上for update，利用了数据库的行锁或是表锁特性来进行实现，但如果使用不当，会严重拖累整个操作的执行速度。
下面的实际案例展示了具体的操作，该项目基于 Spring Data JPA 实现：
- 新建两个实体类，
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.1 实体类添加 version 字段并用相应的
@Version进行标记，这种方式较为简单方便(如上User)； - 2.2 在进行更新操作的时候进行 version 判断，需要自己写 SQL 实现(如下)
public interface UserRepository extends JpaRepository<User, Integer> { /** * 乐观锁实现方式②：在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); } - 2.1 实体类添加 version 字段并用相应的
-
悲观锁的实现也有两种：
- 3.1 添加
@Lock注解，并设置值为LockModeType.PESSIMISTIC_WRITE即可代表行级锁，同样这种方式也容易操作
public interface TeacherRepository extends JpaRepository<Teacher, Integer> { /** * 悲观锁实现①：使用@Lock注解，并且设置值为LockModeType.PESSIMISTIC_WRITE */ @Override @Lock(value = LockModeType.PESSIMISTIC_WRITE) Optional<Teacher> findById(Integer id); }- 3.2 自行写 SQL 语句，然后结尾加上
for update(如下)
public interface TeacherRepository extends JpaRepository<Teacher, Integer> { /** * 悲观锁实现②：手写SQL，结尾加上for update */ @Query(value = "select t.* from teacher t where t.id = ?1 for update", nativeQuery = true) Optional<Teacher> findTeacherForUpdate(int id); } - 3.1 添加
编写测试用例：
@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);
}
}
- 最终结论
采用乐观锁，操作失败后会抛出ObjectOptimisticLockingFailureException;
使用悲观锁，上述两条操作里面，最终只有先获取到锁的那条操作可以成功执行。
参考链接
文章已授权转载，原文链接：基于 Spring Data JPA 聊聊悲观锁和乐观锁
