极客笔记java乐观锁与悲观锁
引言
并发编程是当前互联网时代的一个重要话题，它在提升系统性能和资源利用率方面起着至关重要的作用。在多线程的环境下，数据的一致性和并发性是需要高度关注的问题。为了保证数据的一致性，我们需要采取一些并发控制机制，如乐观锁和悲观锁。
在Java中，乐观锁和悲观锁是常用的两种并发控制机制。本文将详细介绍乐观锁和悲观锁的概念、使用场景以及在Java中的实现方法等内容。
乐观锁
乐观锁是一种基于“乐观”策略的并发控制机制，它认为多个线程之间的读写操作不会发生冲突。因此，乐观锁在读取数据时不会加锁，只在更新数据时才会进行冲突检测。它的核心思想是：“先进行操作，然后再检查是否冲突”。
在Java中，乐观锁的实现一般依赖于CAS（Compare And Swap）操作。CAS是一种原子操作，它通过比较内存地址上的值和期望值，如果相等则更新为新值，否则不做任何操作。CAS操作是原子的、快速的，并且不会阻塞线程。
下面是一个简单的乐观锁示例代码：
public class OptimisticLockExample {
private int count;
public void increment() {
int newValue;
do {
newValue = getValue() + 1; // 获取当前值并递增
} while (!compareAndSwap(getValue(), newValue)); // 不断尝试更新直到成功
// 更新成功后继续执行其他操作
// ...
}
public int getValue() {
return count;
}
public boolean compareAndSwap(int oldValue, int newValue) {
// 使用CAS操作来比较并交换值
// ...
}
}
在上面的示例中，increment()方法使用乐观锁的方式来递增计数器的值。它会不断尝试更新计数器的值直到成功。如果在更新过程中发现其他线程已经修改了计数器的值，则需要重新获取最新的值并进行更新。这样可以保证计数器最终的值是正确的。
悲观锁
相对于乐观锁，悲观锁是一种基于“悲观”策略的并发控制机制，它认为多个线程之间的读写操作会发生冲突。因此，悲观锁在读取数据时会加锁，以确保数据的一致性。在Java中，悲观锁的实现一般依赖于synchronized关键字、ReentrantLock等锁机制。
悲观锁的实现通常分为两步：加锁和业务处理。加锁的目的是为了阻塞其他线程对数据的访问，保证每次只有一个线程可以对数据进行操作。业务处理阶段是对数据进行操作和更新。在业务处理完成后，需要释放锁，以便其他线程可以获取锁并进行操作。
下面是一个简单的悲观锁示例代码：
public class PessimisticLockExample {
private int count;
private final ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock(); // 加锁
try {
int newValue = getValue() + 1; // 获取当前值并递增
setValue(newValue); // 更新值
} finally {
lock.unlock(); // 释放锁
}
// 继续执行其他操作
// ...
}
public int getValue() {
return count;
}
public void setValue(int value) {
count = value;
}
}
在上面的示例中，increment()方法使用悲观锁的方式来递增计数器的值。通过调用lock()方法来获取锁，进而阻塞其他线程对计数器的访问。在获取锁之后，可以进行业务处理并且更新计数器的值。最后，通过调用unlock()方法来释放锁，以便其他线程可以获取锁并继续操作。
乐观锁与悲观锁的比较
乐观锁和悲观锁是两种不同的并发控制机制，它们在应用场景、实现方式和性能方面存在差异。
应用场景
乐观锁适合于读操作较多的场景，因为读操作不需要对数据进行加锁，可以提供较高的并发性。悲观锁适合于写操作较多的场景，因为写操作需要对数据进行加锁，以保证数据的一致性。
实现方式
乐观锁的实现依赖于CAS操作或版本号机制。CAS操作是原子的、快速的，并且不会阻塞线程，因此乐观锁的性能较好。悲观锁的实现一般依赖于锁机制，如synchronized关键字或ReentrantLock等。悲观锁使用起来较为简单，但是性能较差。
性能比较
乐观锁相对于悲观锁具有更好的性能。乐观锁在读操作较多的情况下，由于不存在锁竞争，因此可以提供较高的并发性。而悲观锁在写操作较多的情况下，由于需要频繁加锁和释放锁，导致线程之间的竞争较为激烈，性能较差。
然而，乐观锁并不适合于所有的场景。在并发度较高或存在复杂的业务逻辑时，由于乐观锁需要不断尝试更新数据并处理冲突，可能会导致额外的开销。此时，悲观锁可能更加适合。
总结
本文详细介绍了Java中的乐观锁和悲观锁的概念、使用场景以及在Java中的实现方法。乐观锁适合于读操作较多的场景，它通过CAS操作或版本号机制来实现并发控制，并具有较好的性能。而悲观锁适合于写操作较多的场景，它通过加锁机制来保证数据的一致性，但性能较差。
乐观锁和悲观锁都有各自的优缺点，选择合适的并发控制机制需要根据具体的业务场景来决定。在实际应用中，我们可以根据需求的特点来选择使用乐观锁或悲观锁，或者结合两者进行灵活的使用。
参考代码
乐观锁示例代码
public class OptimisticLockExample {
private int count;
public void increment() {
int newValue;
do {
newValue = getValue() + 1; // 获取当前值并递增
} while (!compareAndSwap(getValue(), newValue)); // 不断尝试更新直到成功
// 更新成功后继续执行其他操作
// ...
}
public int getValue() {
return count;
}
public boolean compareAndSwap(int oldValue, int newValue) {
// 使用CAS操作来比较并交换值
// ...
}
}
悲观锁示例代码
public class PessimisticLockExample {
private int count;
private final ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock(); // 加锁
try {
int newValue = getValue() + 1; // 获取当前值并递增
setValue(newValue); // 更新值
} finally {
lock.unlock(); // 释放锁
}
// 继续执行其他操作
// ...
}
public int getValue() {
return count;
}
public void setValue(int value) {
count = value;
}
}
通过使用乐观锁和悲观锁，我们可以在并发环境中实现对共享数据的安全访问和更新。乐观锁通过通过CAS操作或版本号机制来实现并发控制，并具有较好的性能。悲观锁通过加锁机制来保证数据的一致性，但性能较差。根据具体的业务场景，我们可以选择合适的并发控制机制来提升系统的性能和资源利用率。