悲观锁和乐观锁详解

在数据库和多线程编程中，锁的机制是确保数据一致性和安全性的重要手段。常见的锁机制有悲观锁和乐观锁，它们各自有不同的使用场景和实现方式。本文将详细讲解这两种锁的定义、特点、优缺点以及代码示例。

悲观锁

定义：悲观锁（Pessimistic Lock）是一种假设数据在操作过程中会被其他事务或线程修改，因此在读取和写入数据之前，会锁定相关的资源，其他事务或线程必须等待这个锁释放才能进行操作。

特点： 1. 对共享资源加锁，确保在操作期间不会被其他线程或事务访问。 2. 一般采用排他锁（exclusive lock），即锁定后其他操作无法获取锁。 3. 通常适用于高并发场景，尤其是在写操作频繁的情况下。

优缺点： - 优点：数据的一致性和安全性高，有效防止了脏读、不可重复读等问题。 - 缺点：可能导致死锁，性能开销大，特别是在长时间持有锁的情况下，容易造成线程阻塞。

示例代码（使用Java的ReentrantLock作为悲观锁）：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PessimisticLockExample {
    private static final Lock lock = new ReentrantLock();
    private static int sharedResource = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> updateResource());
        Thread t2 = new Thread(() -> updateResource());

        t1.start();
        t2.start();
    }

    private static void updateResource() {
        lock.lock(); // 加锁
        try {
            System.out.println(Thread.currentThread().getName() + " 正在更新资源");
            sharedResource++;
            // 模拟一些复杂的处理
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 解锁
            System.out.println(Thread.currentThread().getName() + " 更新完成，当前资源值：" + sharedResource);
        }
    }
}

乐观锁

定义：乐观锁（Optimistic Lock）是一种假设数据在操作过程中不会被他人修改，因此不对数据加锁。在提交更新时，如果发现数据已经被修改，则拒绝更新。

特点： 1. 不会在读取时加锁，具有较高的并发性能。 2. 检查版本或时间戳等机制来确定是否可以进行更新。 3. 适用于读多写少的场景。

优缺点： - 优点：减少了锁竞争，提高了系统的并发性能。 - 缺点：可能导致重试机制，略显复杂，当数据冲突频繁时性能下降。

示例代码（使用版本号实现乐观锁）：

public class OptimisticLockExample {
    private static class Resource {
        private int value;
        private int version;

        public Resource(int value, int version) {
            this.value = value;
            this.version = version;
        }
    }

    private static Resource sharedResource = new Resource(0, 0);

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> updateResource());
        Thread t2 = new Thread(() -> updateResource());

        t1.start();
        t2.start();
    }

    private static void updateResource() {
        int localVersion;
        int newValue;

        while (true) {
            synchronized (sharedResource) {
                localVersion = sharedResource.version;
                newValue = sharedResource.value + 1;
                // 模拟一些处理
            }

            // 模拟更新，假设数据存储在数据库中
            if (updateValueInDatabase(newValue, localVersion)) {
                System.out.println(Thread.currentThread().getName() + " 更新成功，当前值：" + newValue);
                break;
            } else {
                System.out.println(Thread.currentThread().getName() + " 更新失败，数据已被修改，重试...");
            }
        }
    }

    private static boolean updateValueInDatabase(int newValue, int oldVersion) {
        synchronized (sharedResource) {
            if (sharedResource.version == oldVersion) {
                sharedResource.value = newValue;
                sharedResource.version++; // 更新版本号
                return true; // 更新成功
            } else {
                return false; // 更新失败
            }
        }
    }
}

总结

悲观锁和乐观锁各有其优缺点，选择使用哪种锁机制需要根据实际情况来定。如果应用场景中写操作频繁且可能产生竞争，悲观锁可能更合适；而在读操作远多于写操作的场景下，乐观锁则能提供更好的性能。合理选择锁机制对于系统的性能和稳定性至关重要。