悲观锁和乐观锁详解

大家好，欢迎来到IT知识分享网。

        乐观锁和悲观锁是并发控制的一种机制，用于多线程或多进程环境下对共享资源的访问管理，以防止数据不一致或竞态条件。它们的主要区别在于对待冲突的策略。

一、悲观锁（Pessimistic Locking） 

        悲观锁是一种对资源持有较悲观态度的锁定方式。它假设数据在并发访问时极有可能发生冲突，因此每次访问数据时都会先加锁，以确保其他线程不能访问此数据直到锁被释放。主要特点包括： 

1、锁定机制：一旦线程获得锁，其它尝试获取锁的线程都会被阻塞，直到锁被释放。常见的实现方式是数据库中的行级锁、表级锁或行级锁等。

2、适用场景：在高并发、数据竞争激烈的场景中使用，如金融交易、库存管理等。这类场景下，冲突发生的可能性很高，所以加锁确保数据的一致性。 

3、 缺点：

        （1）可能导致系统吞吐量降低，因为锁定机制会阻止其他线程并发访问资源。

        （2）容易产生死锁（Deadlock），如果锁的持有和释放管理不当，会导致系统无法继续运行 。

4、代码示例 :

public class BankAccount { private double balance; public BankAccount(double initialBalance) { this.balance = initialBalance; } // 同步方法，用于存款 public synchronized void deposit(double amount) { double newBalance = balance + amount; balance = newBalance; // 更新余额 System.out.println("存款: " + amount + ", 余额: " + balance); } // 同步方法，用于取款 public synchronized void withdraw(double amount) { if (balance >= amount) { balance -= amount; System.out.println("取款: " + amount + ", 余额: " + balance); } else { System.out.println("余额不足"); } } // 同步方法，获取余额 public synchronized double getBalance() { return balance; } public static void main(String[] args) { BankAccount account = new BankAccount(1000); // 创建线程执行存款操作 Thread depositThread = new Thread(() -> { account.deposit(200); }); // 创建线程执行取款操作 Thread withdrawThread = new Thread(() -> { account.withdraw(150); }); depositThread.start(); withdrawThread.start(); } } 

二、乐观锁（Optimistic Locking） 

        乐观锁则持相对乐观的态度，假设并发操作冲突的可能性较小，因此不会主动加锁，而是进行数据版本检查来决定是否提交操作。主要特点包括： 

1、版本控制：乐观锁一般通过版本号或时间戳等机制来实现。在数据读取时，获取当前版本号，在数据更新时，检查版本号是否与之前读取时的一致。如果一致，表示没有其他并发操作修改过数据，可以提交；否则，操作失败，通常需要重试。 

2、 适用场景：适用于读操作多、写操作少的场景，如一些阅读类应用、CMS系统等。因为这些场景下，冲突发生的概率较低，乐观锁可以提高系统的并发性。

3、优点：

        （1）提高系统并发性能，因为不需要加锁阻塞其他线程。

        （2）减少死锁的风险，因为不使用显式锁定。

4、缺点：

        （1）在并发冲突频繁的场景下，可能会导致大量重试操作，影响性能。

        （2）需要开发人员显式管理版本控制机制，增加开发复杂度。

5、代码示例： 

 实体类：

import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Version; @Entity public class Product { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private int quantity; @Version private int version; // getters and setters 省略 } 

 Repository接口：

import org.springframework.data.jpa.repository.JpaRepository; public interface ProductRepository extends JpaRepository<Product, Long> { } 

服务类： 

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service public class ProductService { @Autowired private ProductRepository productRepository; @Transactional public void updateProduct(Long productId, int newQuantity) { Product product = productRepository.findById(productId).orElseThrow(() -> new RuntimeException("产品没找到")); product.setQuantity(newQuantity); productRepository.save(product); } } 

测试乐观锁： 

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.CommandLineRunner; import org.springframework.stereotype.Component; @Component public class OptimisticLockTestRunner implements CommandLineRunner { @Autowired private ProductService productService; @Override public void run(String... args) throws Exception { Long productId = 1L; // 模拟第一个事务 new Thread(() -> { try { productService.updateProduct(productId, 50); System.out.println("线程1: 产品更新成功"); } catch (Exception e) { System.out.println("线程1: " + e.getMessage()); } }).start(); // 模拟第二个事务 new Thread(() -> { try { Thread.sleep(1000); // 保证第一个事务先执行 productService.updateProduct(productId, 100); System.out.println("线程2: 产品更新成功"); } catch (Exception e) { System.out.println("线程2: " + e.getMessage()); } }).start(); } }