Java多线程之悲观锁与乐观锁

Java多线程之悲观锁与乐观锁攻略

概述

在多线程编程中，为了保证数据的安全，我们需要使用锁机制来控制对共享资源的访问。其中，悲观锁是一种传统的锁模式，它认为在每次访问共享资源时都有可能发生冲突，所以对共享资源进行加锁以防止其他线程的访问。而乐观锁则是一种更为轻量级的锁模式，它的思想是假设多线程之间没有冲突，当发生冲突时再进行处理。

本文将详细介绍悲观锁和乐观锁机制的实现，以及它们在Java多线程编程中的应用。

悲观锁

悲观锁机制是一种比较保守的加锁策略。在每次访问共享资源时，都会进行加锁，以防止其他线程的干扰。常见的悲观锁实现方式有synchronized关键字和Lock接口。

使用synchronized关键字实现悲观锁

synchronized关键字是Java语言内置的一种锁机制，它可以用来保护对共享资源的访问，实现线程互斥。在使用synchronized关键字进行加锁时，需要在方法名或代码块前添加synchronized关键字，以标识该方法或代码块是同步方法或同步代码块。

下面的示例展示了如何使用synchronized关键字实现悲观锁机制：

public class SynchronizedDemo {
    private int count = 0;

    public synchronized void increase() {
        count++;
    }
}

注意，在synchronized关键字实现悲观锁时，需要保证共享资源的属性都是private的，并只通过公共方法进行访问，以保证线程安全。此外，由于synchronized关键字是Java语言内置的锁机制，因此它的性能相对较低。

使用Lock接口实现悲观锁

除了synchronized关键字外，Java还提供了Lock接口来实现悲观锁机制。与synchronized关键字相比，Lock接口提供了更为灵活的锁操作。在使用Lock接口实现悲观锁机制时，需要先创建一个Lock对象，然后在访问共享资源的代码块中调用lock方法获取锁，并在代码块执行完毕后调用unlock方法释放锁。

下面的示例展示了如何使用Lock接口实现悲观锁机制：

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

    public void increase() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

注意，在使用Lock接口实现悲观锁机制时，需要保证在获取锁后一定要释放锁，否则会导致死锁等问题。

乐观锁

乐观锁机制是一种更为轻量级的锁模式，它的思想是假设多线程之间没有冲突，当发生冲突时再进行处理。常见的乐观锁实现方式有版本号机制和CAS算法。

版本号机制

版本号机制是一种乐观锁实现方式。在使用版本号机制时，需要为共享资源添加一个版本号属性，并在每次访问该共享资源时，同时获取该共享资源的版本号，当进行修改操作时，需要将版本号加1。当发生冲突时，需要根据版本号的更新情况来判断哪个线程的操作被覆盖，从而进行相应的处理。

下面的示例展示了如何使用版本号机制实现乐观锁机制：

public class VersionDemo {
    private int value = 0;
    private volatile int version = 0;

    public void increase() {
        while (true) {
            int oldVersion = version;
            int oldValue = value;

            // 修改操作
            value = oldValue + 1;
            version = oldVersion + 1;

            // 判断修改过程中是否发生冲突
            if (version == oldVersion + 1) {
                break;
            }
        }
    }
}

注意，在使用版本号机制实现乐观锁时，需要保证共享资源的版本号属性是volatile修饰的，以保证可见性和有序性。

CAS算法

CAS（Compare And Swap）算法是一种更为高效的乐观锁实现方式。在使用CAS算法实现乐观锁时，需要使用Atomic类对共享资源进行包装，这样可以保证对共享资源的操作是原子操作，从而避免了多线程同时访问共享资源的问题。

下面的示例展示了如何使用Atomic类和CAS算法实现乐观锁机制：

public class CASDemo {
    private AtomicInteger value = new AtomicInteger(0);

    public void increase() {
        while (true) {
            int oldValue = value.get();
            int newValue = oldValue + 1;

            // 使用CAS算法进行修改操作
            if (value.compareAndSet(oldValue, newValue)) {
                break;
            }
        }
    }
}

注意，使用CAS算法实现乐观锁时，需要保证对共享资源的操作是原子操作，否则可能会导致CAS操作失败。此外，由于CAS算法是基于硬件实现的，因此它的性能相对于其他锁机制较高。

结论

悲观锁和乐观锁是Java多线程编程中常用的锁机制。在使用锁机制时，需要根据实际情况选择合适的锁机制，以保证程序的正确性和性能。在选择锁机制时，除了考虑锁的实现方式外，还需要考虑锁的性能、可扩展性、死锁和饥饿等问题，以确保程序的稳定和可靠。