简单了解下Java中锁的概念和原理

你好，这里是codetrend专栏“高并发编程基础”。

Java提供了很多种锁的接口和实现，通过对各种锁的使用发现理解锁的概念是很重要的。

Java的锁通过java代码实现，go语言的锁通过go实现，python语言的锁通过python实现。它们都实现的什么呢？这部分就是锁的定义和设计模式、算法、原理等一些理论上的东西。

下文基于此说明Java常见的锁分类和原理。

乐观锁&悲观锁

乐观锁和悲观锁是在并发编程中保证数据一致性的两种常见的锁机制。

乐观锁：乐观锁假设在大多数情况下，不会出现并发冲突，因此在读取数据时并不加锁，只有在提交更新时才会检查是否有其他并发操作修改了数据。如果检测到了冲突，就放弃当前的操作并返回错误信息。通常采用版本号或时间戳等机制来实现乐观锁。乐观锁机制适用于读操作频繁、写操作较少的场景。

悲观锁：悲观锁则假设并发冲突随时都可能发生，因此在读取数据时就会加锁，直到操作完成后才会释放锁。一般可以使用数据库中的行级锁、表级锁或者使用 synchronized 等语言提供的锁机制来实现悲观锁。悲观锁机制适用于写操作频繁、读操作较少的场景。

选择何种锁机制应根据具体的应用场景进行选择。在读写比例不明显的情况下，可以考虑使用乐观锁机制，这样可以减少锁竞争带来的性能损失。如果读写比例明显，考虑使用悲观锁机制可以更好地确保数据的一致性。

需要注意的是，在实际应用中，乐观锁和悲观锁并不是严格的对立关系，而是可以结合使用的。例如，在高并发场景中，可以使用乐观锁机制来减少对数据库的压力，但在必要的时候也可以使用悲观锁机制来确保数据的一致性。

下面是使用 Java 实现一个简单的乐观锁和悲观锁的示例：

乐观锁示例：

import java.util.concurrent.atomic.AtomicInteger;

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

    public void increment() {
   
        int oldValue, newValue;
        while (!value.compareAndSet(oldValue, newValue)){
   
            // CAS操作，如果值没有被修改，则更新为新值
            // 读取当前值
            oldValue = value.get();
            // 计算新值
            newValue = oldValue + 1;
        } 
    }

    public int getValue() {
   
        return value.get();
    }
}

悲观锁示例：

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

public class PessimisticLock {
   
    private int value = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
   
        lock.lock(); // 加锁
        try {
   
            value++; // 更新数据
        } finally {
   
            lock.unlock(); // 解锁
        }
    }

    public int getValue() {
   
        return value;
    }
}

公平锁&非公平锁

公平锁：公平锁保证线程获取锁的顺序与其请求锁的顺序相同，即先到先得。当多个线程同时竞争同一个公平锁时，这些线程会按照先后顺序排队等待获取锁。公平锁可以避免饥饿现象，但是由于需要维护一个有序队列，因此性能较低。

非公平锁：非公平锁则不保证线程获取锁的顺序，即先到不一定先得。当一个线程释放锁时，如果有多个线程正在等待获取锁，那么当前持有锁的线程有可能会再次获取到锁，而不是让等待时间最长的线程获取锁。非公平锁具有更高的吞吐量和更低的竞争开销，但是容易导致某些线程长时间等待，出现饥饿现象。

在 Java 中，可以使用 ReentrantLock 类来实现公平锁和非公平锁。默认情况下，ReentrantLock 类使用非公平锁，可以通过构造函数传入 true 来创建公平锁，例如：

// 创建公平锁
Lock fairLock = new ReentrantLock(true);

// 创建非公平锁
Lock unfairLock = new ReentrantLock(false);

自旋锁&适应性自旋锁

自旋锁和适应性自旋锁都是基于忙等待的锁机制，它们在获取锁时不会立即阻塞线程，而是反复检查锁的状态，直到获取到锁为止。下面对每种锁做一些说明，并提供Java中的实现示例。

自旋锁：自旋锁适合用于锁持有时间非常短暂的情况，可以避免线程切换带来的开销。自旋锁的基本思想是，当线程发现共享资源已经被其他线程占用时，就进行自旋等待，直到占用共享资源的线程释放锁为止。Java中的ReentrantLock就支持自旋锁，可以通过构造函数的参数来设置自旋次数，例如：

ReentrantLock lock = new ReentrantLock(true); // 使用公平锁
lock.lock(); // 获取锁
// 共享资源的访问操作
lock.unlock(); // 释放锁

适应性自旋锁：适应性自旋锁是一种优化过的自旋锁，它会根据前一次在同一个锁上的自旋时间和锁的拥有者情况来确定自旋次数。如果在同一个锁上，前一次自旋的时间较长，那么下一次就会更倾向于阻塞线程而不是自旋等待。这样可以避免长时间的自旋等待，减少资源的浪费。Java中的StampedLock就是支持适应性自旋锁的一种锁机制，例如：

StampedLock lock = new StampedLock();
long stamp = lock.readLock(); // 获取悲观读锁
// 共享资源的访问操作
lock.unlockRead(stamp); // 释放悲观读锁

无锁 & 偏向锁 & 轻量级锁 & 重量级锁

无锁、偏向锁、轻量级锁和重量级锁都是Java中不同的锁状态，用于实现线程同步的机制。

无锁：无锁是指在多线程环境下，对共享资源的访问没有任何同步控制，所有线程可以同时访问共享资源，不会发生争用。无锁适用于只读操作或者线程冲突非常少的情况。例如：

int value = sharedValue; // 读取共享资源

偏向锁：偏向锁是一种针对加锁操作进行优化的机制，它适用于只有一个线程反复获取锁的情况。当一个线程首次获取锁时，会将锁的标记设置为该线程，下次该线程再次获取锁时无需竞争，直接进入临界区。偏向锁的目标是提高单线程下的性能。例如：

// 线程1首次获取锁
synchronized (lock) {
   
    // 临界区代码
}

// 线程1再次获取锁
synchronized (lock) {
   
    // 临界区代码
}

轻量级锁：轻量级锁是一种基于CAS（Compare and Swap）操作的锁机制，它适用于多个线程交替执行同一段临界区代码的情况。当一个线程获取锁时，会尝试使用CAS操作将对象头部的锁记录替换为指向自己的线程ID，如果成功，则表示获取锁成功；否则，表示有其他线程竞争锁，可能发生锁膨胀。例如：

Lock lock = new ReentrantLock();
lock.lock(); // 获取锁
try {
   
    // 临界区代码
} finally {
   
    lock.unlock(); // 释放锁
}

重量级锁：重量级锁是一种基于操作系统互斥量（Mutex）的锁机制，它适用于多个线程频繁竞争同一把锁的情况。当一个线程获取锁时，会进入阻塞状态，直到锁被释放，然后唤醒其他线程进行竞争。重量级锁适用于线程冲突比较频繁的情况。例如：

synchronized (obj) {
   
    // 临界区代码
}

可重入锁 & 非可重入锁

可重入锁：可重入锁是指允许同一线程多次获取同一把锁，而不会发生死锁或者其他异常情况。当一个线程获取锁后，再次尝试获取锁时会自动成功，并且需要释放相同次数的锁才能真正释放锁。Java中的ReentrantLock和synchronized都支持可重入锁，例如：

// ReentrantLock示例
ReentrantLock lock = new ReentrantLock();
lock.lock(); // 获取锁
try {
   
    // 临界区代码
    lock.lock(); // 再次获取锁
    try {
   
        // 嵌套临界区代码
    } finally {
   
        lock.unlock(); // 释放嵌套锁
    }
} finally {
   
    lock.unlock(); // 释放锁
}

非可重入锁：非可重入锁是指同一线程不能多次获取同一把锁，否则会导致死锁或者其他异常情况。Java中的普通对象锁就是一种非可重入锁，例如：

package engineer.concurrent.battle.glock;

public class LockEnterNoRepeat {
   
    private static Object lock = new Object();

    public static void main(String[] args) {
   
        synchronized (lock) {
   
            // 临界区代码
            synchronized (lock) {
    // 再次获取锁会导致死锁
                // 嵌套临界区代码
                System.out.println("thread end");
            }
        }
    }
}

需要注意的是，可重入锁虽然提供了更大的灵活性和便利性，但也要注意避免死锁和其他问题的发生。在设计和使用多线程代码时，应该根据具体情况选择合适的锁机制。

独享锁 & 共享锁

独享锁Exclusive Lock是指在某个时间点只允许一个线程持有锁，其他线程不能同时持有该锁。独享锁也被称为排它锁或写锁，用于保护临界资源的独占访问。

共享锁Shared Lock是指在某个时间点允许多个线程同时持有锁，这些线程可以同时访问被保护的资源，但是不能进行写操作。共享锁也被称为读锁，用于实现读多写少的并发模式。

在Java中，ReentrantReadWriteLock是一种同时支持独享锁和共享锁的锁机制。通过使用ReentrantReadWriteLock，可以在不同的线程之间实现对共享资源的读写操作控制。

下面是使用ReentrantReadWriteLock实现独享锁和共享锁的示例代码：

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
   
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private String data = "Hello, World!";

    public void readData() {
   
        lock.readLock().lock();
        try {
   
            System.out.println("Reading data: " + data);
        } finally {
   
            lock.readLock().unlock();
        }
    }

    public void writeData(String newData) {
   
        lock.writeLock().lock();
        try {
   
            System.out.println("Writing data: " + newData);
            data = newData;
        } finally {
   
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
   
        ReadWriteLockExample example = new ReadWriteLockExample();

        // 创建多个读线程
        for (int i = 0; i < 3; i++) {
   
            Thread readerThread = new Thread(() -> {
   
                example.readData();
            });
            readerThread.start();
        }

        // 创建一个写线程
        Thread writerThread = new Thread(() -> {
   
            example.writeData("New data");
        });
        writerThread.start();
    }
}

运行该程序会输出以下结果：

Reading data: Hello, World!
Reading data: Hello, World!
Reading data: Hello, World!
Writing data: New data

可以看到，有三个读线程同时获取了共享锁，并读取了数据。而在写线程中，只有该线程获取了独享锁，并成功修改了数据。

通过ReentrantReadWriteLock，我们可以实现对共享资源的读操作并发执行，提高读操作的效率；而写操作会独占锁，保证在写操作时只有一个线程能够访问临界资源，确保数据一致性。

关于作者

来自全栈程序员nine的探索与实践，持续迭代中。

欢迎关注和点赞~