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

数据库锁分为乐观锁和悲观锁,前者适合读多写少的场景,后者适合读少写多的场景。乐观锁的实现通常是采用加版本号的形式,即如果更新时版本号未发生改变,则本次操作是成功的,且当前版本号的信息也相应会发生改变;再来看看悲观锁,悲观锁的实现方式是在待执行的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;
}
}
  1. 乐观锁的实现有两种:

    • 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);

      }
  1. 悲观锁的实现也有两种:

    • 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);

      }
  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);
}

}
  1. 最终结论

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

参考链接

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

示例源码
欢迎关注我的个人公众号:超级码里奥
如果这对您有帮助,欢迎点赞和分享,转载请注明出处

× 支持创作
打赏二维码