乐观锁和悲观锁的概念、实现方式及适用场景

概念解释

悲观锁： 悲观锁是一种悲观的并发控制策略，它假设在数据处理过程中，很可能会发生冲突，因此在数据处理前就先获取锁，确保在整个数据处理过程中，数据不会被其他事务修改。只有当前事务完成后，才会释放锁，其他事务才能获取该数据。

乐观锁： 乐观锁是一种乐观的并发控制策略，它假设在数据处理过程中，不太可能发生冲突，因此在数据处理前不获取锁。而是在更新数据时，检查数据是否被其他事务修改过。如果数据未被修改，则更新成功；如果数据已被修改，则更新失败，需要进行重试或其他处理。

实现方式

悲观锁的实现方式

1. 数据库锁：

   • 行锁：例如MySQL的SELECT ... FOR UPDATE语句
   • 表锁：例如MySQL的LOCK TABLES语句
   • 页锁：例如InnoDB的页面级锁

2. 编程语言中的锁：

   • Java中的synchronized关键字
   • Java中的ReentrantLock类
   • Python中的threading.Lock类
   • C#中的lock关键字

3. 分布式锁：

   • 基于Redis的分布式锁（如RedLock算法）
   • 基于ZooKeeper的分布式锁
   • 基于数据库的分布式锁

乐观锁的实现方式

1. 版本号机制：

   • 在数据表中添加一个版本号字段（version）
   • 更新数据时检查版本号是否发生变化
   • 如果版本号未变，则更新数据并增加版本号
   • 如果版本号已变，则更新失败

2. 时间戳机制：

   • 在数据表中添加一个时间戳字段（timestamp）
   • 更新数据时检查时间戳是否发生变化
   • 如果时间戳未变，则更新数据并更新时间戳
   • 如果时间戳已变，则更新失败

3. CAS（Compare And Swap）操作：

   • 原子操作，比较内存中的值与预期值是否相等
   • 如果相等，则将新值写入内存
   • 如果不相等，则操作失败
   • Java中的AtomicInteger、AtomicLong等类使用了CAS操作

4. MD5校验和：

   • 在读取数据时计算数据的MD5值
   • 更新数据时重新计算MD5值并与之前的比较
   • 如果MD5值相同，则更新数据
   • 如果MD5值不同，则更新失败

适用场景

悲观锁的适用场景

1. 写操作频繁：当对数据的写操作远多于读操作时，使用悲观锁可以避免大量的更新冲突。
2. 冲突可能性高：当多个事务同时修改同一数据的可能性很高时，使用悲观锁可以确保数据的一致性。
3. 数据一致性要求高：当对数据的一致性要求非常高，不能接受任何数据冲突时，使用悲观锁可以确保数据的一致性。
4. 事务执行时间长：当一个事务执行时间较长，期间数据被其他事务修改的可能性较高时，使用悲观锁可以确保数据的一致性。

乐观锁的适用场景

1. 读操作频繁：当对数据的读操作远多于写操作时，使用乐观锁可以提高系统的并发性能。
2. 冲突可能性低：当多个事务同时修改同一数据的可能性很低时，使用乐观锁可以提高系统的并发性能。
3. 系统性能要求高：当对系统的性能要求非常高，需要尽可能减少锁的开销时，使用乐观锁可以提高系统的性能。
4. 事务执行时间短：当一个事务执行时间很短，期间数据被其他事务修改的可能性较低时，使用乐观锁可以提高系统的并发性能。

优缺点对比

代码示例

悲观锁示例（Java）

// 使用synchronized关键字实现悲观锁
public class PessimisticLockExample {
    private int count = 0;
    
    // synchronized关键字确保同一时间只有一个线程可以执行该方法
    public synchronized void increment() {
        count++;
    }
    
    public int getCount() {
        return count;
    }
}

// 使用ReentrantLock实现悲观锁
import java.util.concurrent.locks.ReentrantLock;

public class PessimisticLockExample2 {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;
    
    public void increment() {
        lock.lock();  // 获取锁
        try {
            count++;
        } finally {
            lock.unlock();  // 释放锁
        }
    }
    
    public int getCount() {
        return count;
    }
}

乐观锁示例（Java）

// 使用版本号实现乐观锁
public class OptimisticLockExample {
    private int count = 0;
    private int version = 0;
    
    public boolean increment() {
        int currentVersion = version;
        // 模拟一些处理时间
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // 检查版本号是否变化
        if (currentVersion == version) {
            count++;
            version++;
            return true;  // 更新成功
        } else {
            return false;  // 更新失败
        }
    }
    
    public int getCount() {
        return count;
    }
    
    public int getVersion() {
        return version;
    }
}

// 使用AtomicInteger实现乐观锁（基于CAS）
import java.util.concurrent.atomic.AtomicInteger;

public class OptimisticLockExample2 {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        // 使用CAS操作实现原子递增
        count.incrementAndGet();
    }
    
    public int getCount() {
        return count.get();
    }
}

数据库中的悲观锁和乐观锁示例

-- 悲观锁示例（MySQL）
-- 开始事务
START TRANSACTION;

-- 使用SELECT ... FOR UPDATE获取行锁
SELECT * FROM products WHERE id = 1 FOR UPDATE;

-- 更新数据
UPDATE products SET stock = stock - 1 WHERE id = 1;

-- 提交事务，释放锁
COMMIT;

-- 乐观锁示例（MySQL）
-- 假设products表有一个version字段
-- 开始事务
START TRANSACTION;

-- 读取数据和版本号
SELECT id, name, stock, version FROM products WHERE id = 1;

-- 更新数据时检查版本号
UPDATE products 
SET stock = stock - 1, version = version + 1 
WHERE id = 1 AND version = [之前读取的版本号];

-- 检查是否更新成功
-- 如果受影响的行数为0，说明版本号已变化，更新失败
-- 提交事务
COMMIT;

可视化图表

悲观锁工作流程图

乐观锁工作流程图

乐观锁与悲观锁对比图

乐观锁CAS操作时序图