在并发编程中，锁（Lock）是一种用于控制多个线程对共享资源访问的机制。正确使用锁可以确保数据的一致性和完整性，避免出现竞态条件（Race Condition）、死锁（Deadlock）等问题。Java 提供了多种类型的锁来满足不同场景下的需求，从内置的对象锁到更高级别的 java.util.concurrent.locks 包中的显式锁。

为什么需要锁？

当多个线程同时尝试修改同一份数据时，如果没有适当的同步措施，可能会导致以下问题：

• 数据不一致：不同的线程读取到了部分更新的数据。
• 丢失更新：一个线程的更改被另一个线程覆盖。
• 脏读/写：线程读取或写入了尚未完成的操作。

为了解决这些问题，我们需要一种机制来协调线程之间的访问顺序，保证每次只有一个线程能够操作共享资源。这就是锁的作用所在。

Java 中的锁类型

内置锁（Intrinsic Lock）

也称为监视器锁（Monitor Lock），是通过关键字 synchronized 实现的。每个对象都有一个与之关联的内置锁，当一个线程进入由 synchronized 修饰的方法或代码块时，它会自动获取该对象的锁；而当方法执行完毕或遇到 wait() 调用时，则会释放锁。

public synchronized void method() {
    // 只有一个线程可以进入这里
}

public void method() {
    synchronized (this) {
        // 同样只有一个线程可以进入这里
    }
}

显式锁（Explicit Lock）

从 Java 5 开始，java.util.concurrent.locks 包引入了更为灵活和强大的锁接口——Lock。相比于内置锁，显式锁提供了更多的功能，如可中断的锁等待、超时获取锁以及公平锁等特性。

ReentrantLock

ReentrantLock 是最常用的显式锁实现之一，它允许同一个线程多次获取同一把锁，并且必须按照获取的次数逐一释放。这使得递归调用成为可能。

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

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

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 确保无论如何都会解锁
        }
    }

    public int getCount() {
        return count;
    }
}

ReadWriteLock

ReadWriteLock 接口定义了一种读写分离的锁机制，其中读锁允许多个线程同时持有，但不允许写锁存在；反之，一旦有线程持有了写锁，其他所有试图获取读锁或写锁的线程都将被阻塞。这种设计非常适合读多写少的情况。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Cache {
    private final Map<String, Object> map = new HashMap<>();
    private final ReadWriteLock rwl = new ReentrantReadWriteLock();

    public Object get(String key) {
        rwl.readLock().lock();
        try {
            return map.get(key);
        } finally {
            rwl.readLock().unlock();
        }
    }

    public void put(String key, Object value) {
        rwl.writeLock().lock();
        try {
            map.put(key, value);
        } finally {
            rwl.writeLock().unlock();
        }
    }
}

StampedLock

StampedLock 是 Java 8 新增的一种乐观锁，它结合了读写锁的功能并提供了更好的性能优化。它支持三种模式：读、写和乐观读。乐观读模式假设不会有冲突发生，因此不会阻塞其他线程；但如果检测到冲突，则需要回滚操作并重新尝试。

import java.util.concurrent.locks.StampedLock;

public class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();

    void move(double deltaX, double deltaY) { 
        long stamp = sl.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    double distanceFromOrigin() { 
        long stamp = sl.tryOptimisticRead();
        double currentX = x, currentY = y;
        if (!sl.validate(stamp)) {
            stamp = sl.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

锁的使用原则

• 最小化锁定范围：尽量减少加锁的时间和区域，只保护真正需要保护的资源。
• 避免死锁：设计时要特别小心，防止形成循环等待链，即多个线程互相持有对方所需的锁。
• 使用超时机制：对于可能长时间阻塞的操作，考虑设置合理的超时时间以提高系统的健壮性。
• 优先选择高级并发工具：相比于原始的内置锁，应该更多地利用 java.util.concurrent 包中提供的高级工具，因为它们通常更加安全可靠且易于使用。
• 文档化锁协议：清晰地记录各个锁之间的关系和使用规则，有助于后续维护人员理解代码逻辑。

最佳实践案例

使用 ReentrantLock 替代内置锁

在某些情况下，ReentrantLock 可以为我们提供比内置锁更多的灵活性。例如，它可以让我们实现非阻塞的锁尝试 (tryLock) 或者带超时的锁等待 (tryLock(long timeout, TimeUnit unit)).

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

public class BankAccount {
    private double balance;
    private final Lock lock = new ReentrantLock();

    public boolean withdraw(double amount) throws InterruptedException {
        if (lock.tryLock(1, TimeUnit.SECONDS)) {
            try {
                if (balance >= amount) {
                    balance -= amount;
                    return true;
                }
            } finally {
                lock.unlock();
            }
        }
        return false; // 超时未获得锁或余额不足
    }
}

使用 ReadWriteLock 优化读多写少场景

当应用程序中有大量读操作而写操作相对较少时，ReadWriteLock 可以显著提升性能，因为它允许多个线程同时进行读取，而不必像内置锁那样每次都排他地占用资源。

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ConcurrentCache<K, V> {
    private final Map<K, V> cache = new ConcurrentHashMap<>();
    private final ReadWriteLock rwl = new ReentrantReadWriteLock();

    public V get(K key) {
        rwl.readLock().lock();
        try {
            return cache.get(key);
        } finally {
            rwl.readLock().unlock();
        }
    }

    public void put(K key, V value) {
        rwl.writeLock().lock();
        try {
            cache.put(key, value);
        } finally {
            rwl.writeLock().unlock();
        }
    }
}

使用 StampedLock 进行乐观读

对于那些读操作远多于写操作，并且读操作之间几乎没有竞争的应用程序来说，StampedLock 的乐观读模式可以提供更高的吞吐量。它首先尝试无锁读取，只有在检测到潜在冲突时才会退回到传统的读锁方式。

import java.util.concurrent.locks.StampedLock;

public class OptimisticCounter {
    private long count = 0;
    private final StampedLock sl = new StampedLock();

    public long readCount() {
        long stamp = sl.tryOptimisticRead();
        long localCount = count;
        if (!sl.validate(stamp)) {
            stamp = sl.readLock();
            try {
                localCount = count;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return localCount;
    }

    public void increment() {
        long stamp = sl.writeLock();
        try {
            count++;
        } finally {
            sl.unlockWrite(stamp);
        }
    }
}

结语

感谢您的阅读！如果您对多线程锁或其他并发编程话题有任何疑问或见解，欢迎继续探讨。