Java多线程系列—

0.引言

在并发编程中，锁是一种重要的同步机制，用于控制对共享资源的访问。Java 提供了多种锁的实现，每种锁都有不同的特性和适用场景。本文将深入介绍 Java 中常见的锁类型，包括内置锁、显式锁、读写锁等，并讨论它们的使用方法和最佳实践。

1. 内置锁（synchronized）

内置锁是 Java 中最基本的锁机制，通过 synchronized 关键字来实现。它可以用于同步方法或同步代码块，保证同一时间只有一个线程可以执行被锁定的代码，从而确保线程安全性。

public synchronized void synchronizedMethod() {
    // 同步方法体
}

// 或者

public void synchronizedBlock() {
    synchronized(this) {
        // 同步代码块
    }
}

内置锁的优点是简单易用，但缺点是粒度较粗，无法支持灵活的并发控制。

2. 显式锁（ReentrantLock）

ReentrantLock 是 Java 提供的显式锁实现，它提供了比内置锁更多的功能和灵活性。与 synchronized 相比，ReentrantLock 允许更灵活的加锁与释放锁操作，支持公平性和可中断性。

ReentrantLock lock = new ReentrantLock();

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

显式锁的优点是提供了更多的控制选项，适用于复杂的并发场景，但使用它需要显式地管理锁的获取和释放，容易出错。

3. 读写锁（ReentrantReadWriteLock）

ReentrantReadWriteLock 是一种特殊的锁，它分为读锁和写锁两种。多个线程可以同时持有读锁，但只有一个线程可以持有写锁。这种锁适用于读操作频繁、写操作较少的场景，可以提高并发性能。

ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
ReadWriteLock.ReadLock readLock = rwLock.readLock();
ReadWriteLock.WriteLock writeLock = rwLock.writeLock();

// 读操作
readLock.lock();
try {
    // 读操作代码
} finally {
    readLock.unlock();
}

// 写操作
writeLock.lock();
try {
    // 写操作代码
} finally {
    writeLock.unlock();
}

读写锁的优点是提高了读操作的并发性能，但在写操作频繁的情况下可能导致读操作的饥饿现象。

4. 其他锁

除了上述常见的锁类型外，Java 还提供了诸如StampedLock、Condition、Semaphore 等更多的锁实现，每种锁都有其特定的使用场景和适用性。

5. 锁的选择和最佳实践

在选择锁时，需要根据具体的业务需求和性能要求来进行权衡。一般来说：

如果只需要简单的同步控制，可以使用内置锁；
如果需要更多的控制选项和灵活性，可以使用显式锁；
如果读操作远远多于写操作，可以考虑使用读写锁；
对于特定场景，还可以选择其他类型的锁。

同时，在使用锁的过程中，需要注意避免死锁、锁竞争和锁粒度过大等问题，合理设计锁的获取顺序，并尽量减少锁的持有时间，以提高程序的并发性能和可维护性。

6.举例

假设我们有一个简单的银行账户类 BankAccount，它包含账户余额和提款方法。多个线程可能同时访问同一个银行账户，我们需要确保在进行提款操作时只有一个线程能够访问账户并更新余额，以避免出现并发问题。

我们可以使用锁来控制对共享资源（即账户余额）的访问，确保在任何时候只有一个线程能够执行更新余额的操作。以下是一个使用内置锁（synchronized）的示例：

public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public synchronized void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
            System.out.println(Thread.currentThread().getName() + " withdraws $" + amount + ". Remaining balance: $" + balance);
        } else {
            System.out.println(Thread.currentThread().getName() + " tries to withdraw $" + amount + " but insufficient funds.");
        }
    }

    public double getBalance() {
        return balance;
    }
}

在这个示例中，withdraw() 方法被标记为 synchronized，这意味着只有一个线程可以同时访问该方法。当一个线程调用 withdraw() 方法时，其他线程必须等待直到当前线程执行完毕。

下面是一个简单的测试类，模拟了多个线程同时对银行账户进行提款操作：

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);

        // 创建多个线程同时进行提款操作
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(() -> {
                account.withdraw(200);
            });
            thread.start();
        }
    }
}

在这个例子中，即使有多个线程同时尝试提款，由于 withdraw() 方法被 synchronized 修饰，每次只有一个线程能够成功访问并更新账户余额，从而保证了线程安全性。

通过使用锁来控制对共享资源的访问，我们可以避免并发问题，确保多线程环境下程序的正确性和可靠性。