java------悲观锁和乐观锁

在并发编程中，锁是用于控制多个线程对共享资源访问的机制。悲观锁和乐观锁是两种不同的并发控制策略，它们在处理并发访问时的思路和实现方式有所不同。下面我们将详细讲解悲观锁和乐观锁的概念、特点以及应用场景，并通过示例代码来帮助大家更好地理解。

1. 悲观锁（Pessimistic Locking）

概念解释：
悲观锁是一种悲观的并发控制策略，它假设在最坏的情况下，共享资源会被多个线程同时访问，因此在访问共享资源之前，会先对资源进行加锁，确保同一时间只有一个线程可以访问该资源。

特点：

• 独占性：资源被加锁后，其他线程必须等待锁释放后才能访问。
• 实现方式：通常使用数据库锁（如行级锁、表级锁）或编程语言提供的锁机制（如Java中的 synchronized 关键字、ReentrantLock 类）。
• 适用场景：适用于写操作较多、冲突频率较高的场景。

示例代码：

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

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

    public void increment() {
        lock.lock();  // 加锁
        try {
            count++;  // 访问共享资源
        } finally {
            lock.unlock();  // 释放锁
        }
    }

    public int getCount() {
        lock.lock();  // 加锁
        try {
            return count;  // 访问共享资源
        } finally {
            lock.unlock();  // 释放锁
        }
    }

    public static void main(String[] args) {
        PessimisticLockExample example = new PessimisticLockExample();
        example.increment();
        System.out.println("Count: " + example.getCount());
    }
}

在这个示例中，我们使用 ReentrantLock 类来实现悲观锁，确保在访问共享资源 count 时，只有一个线程可以执行 increment 或 getCount 方法。

2. 乐观锁（Optimistic Locking）

概念解释：
乐观锁是一种乐观的并发控制策略，它假设在大多数情况下，共享资源不会被多个线程同时访问，因此在访问共享资源时不会立即加锁，而是在更新资源时检查资源是否被其他线程修改过。

特点：

• 非独占性：资源在访问时不会被加锁，允许多个线程同时读取资源。
• 实现方式：通常使用版本号或时间戳机制来检测资源是否被修改，或者使用CAS（Compare And Swap）操作。
• 适用场景：适用于读操作较多、冲突频率较低的场景。

示例代码：

import java.util.concurrent.atomic.AtomicInteger;

public class OptimisticLockExample {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        int expectedValue;
        int newValue;
        do {
            expectedValue = count.get();  // 读取当前值
            newValue = expectedValue + 1;  // 计算新值
        } while (!count.compareAndSet(expectedValue, newValue));  // 尝试更新值
    }

    public int getCount() {
        return count.get();  // 读取当前值
    }

    public static void main(String[] args) {
        OptimisticLockExample example = new OptimisticLockExample();
        example.increment();
        System.out.println("Count: " + example.getCount());
    }
}

在这个示例中，我们使用 AtomicInteger 类和 CAS 操作来实现乐观锁，确保在更新共享资源 count 时，不会出现数据冲突。

总结

• 悲观锁：假设在最坏的情况下，共享资源会被多个线程同时访问，因此在访问共享资源之前，会先对资源进行加锁，确保同一时间只有一个线程可以访问该资源。适用于写操作较多、冲突频率较高的场景。
• 乐观锁：假设在大多数情况下，共享资源不会被多个线程同时访问，因此在访问共享资源时不会立即加锁，而是在更新资源时检查资源是否被其他线程修改过。适用于读操作较多、冲突频率较低的场景。

通过以上详细的概念解释和编程示例，相信大家已经对悲观锁和乐观锁有了更深入的理解。在实际编程中，根据具体需求选择合适的并发控制策略，可以提高程序的性能和可维护性。