跳到主要内容

锁（多线程）

多线程编程在现代软件开发中扮演着至关重要的角色。它使我们能够有效地利用多核处理器和提高应用程序的性能。然而，多线程编程也伴随着一系列挑战，其中最重要的之一就是处理共享资源的线程安全性。在这个领域，锁（Lock）是一个关键的概念，用于协调线程之间对共享资源的访问。 作者：flydean 链接：https://www.zhihu.com/question/550510128/answer/3227011144 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

重入锁（Reentrant Lock）​

首先，让我们深入研究一下重入锁，这是 Java 中最常见的锁之一。重入锁是一种可重入锁，这意味着同一线程可以多次获取同一个锁，而不会造成死锁。这种特性使得重入锁在许多复杂的多线程场景中非常有用。重入锁的实现通常需要显式地锁定和解锁，这使得它更加灵活，但也需要开发人员更小心地管理锁的状态。下面是一个简单的示例，演示如何使用重入锁来实现线程安全：

import java.util.concurrent.locks.ReentrantLock;

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

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public int getCount() {
        lock.lock(); // 获取锁
        try {
            return count;
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

在上面的示例中，我们使用 ReentrantLock 来保护 count 字段的访问，确保 increment 和 getCount 方法的线程安全性。请注意，我们在获取锁后使用 try-finally 块来确保在完成操作后释放锁，以防止死锁。

CSDN-ReentrantLock 锁

互斥锁和 synchronized 关键字​

除了重入锁，Java 中还提供了互斥锁的概念，最常见的方式是使用 synchronized 关键字。synchronized 关键字可以用于方法或代码块，以确保同一时刻只有一个线程可以访问被锁定的资源。

例如，我们可以使用 synchronized 来实现与上面示例相同的 Counter 类：

public class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

在这个例子中，我们使用 synchronized 关键字来标记 increment 和 getCount 方法，使它们成为同步方法。这意味着同一时刻只有一个线程可以访问这两个方法，从而确保了线程安全性。

互斥锁和重入锁之间的主要区别在于灵活性和控制。使用 synchronized 关键字更简单，但相对不够灵活，因为它隐式地管理锁。重入锁则需要更显式的锁定和解锁操作，但提供了更多的控制选项。

读写锁（ReadWrite Lock）​

读写锁是一种特殊类型的锁，它在某些场景下可以提高多线程程序的性能。读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。这种机制对于读操作远远多于写操作的情况非常有效，因为它可以提高读操作的并发性。让我们看一个示例，演示如何使用 ReadWriteLock 接口及其实现来管理资源的读写访问：

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

public class SharedResource {
    private int data = 0;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public int readData() {
        lock.readLock().lock(); // 获取读锁
        try {
            return data;
        } finally {
            lock.readLock().unlock(); // 释放读锁
        }
    }

    public void writeData(int newValue) {
        lock.writeLock().lock(); // 获取写锁
        try {
            data = newValue;
        } finally {
            lock.writeLock().unlock(); // 释放写锁
        }
    }
}

在上面的示例中，我们使用 ReentrantReadWriteLock 实现了一个简单的共享资源管理类。readData 方法使用读锁来允许多个线程并发读取 data 的值，而 writeData 方法使用写锁来确保只有一个线程可以修改 data 的值。这种方式可以提高读操作的并发性，从而提高性能。

自旋锁（Spin Lock）​

自旋锁是一种锁定机制，不会让线程进入休眠状态，而是会反复检查锁是否可用。这种锁适用于那些期望锁被持有时间非常短暂的情况，因为它避免了线程进入和退出休眠状态的开销。自旋锁通常在单核或低并发情况下更为有效，因为在高并发情况下会导致 CPU 资源的浪费。以下是一个简单的自旋锁示例：

import java.util.concurrent.atomic.AtomicBoolean;

public class SpinLock {
    private AtomicBoolean locked = new AtomicBoolean(false);

    public void lock() {
        while (!locked.compareAndSet(false, true)) {
            // 自旋等待锁的释放
        }
    }

    public void unlock() {
        locked.set(false);
    }
}

在这个示例中，我们使用了 AtomicBoolean 来实现自旋锁。lock 方法使用自旋等待锁的释放，直到成功获取锁。unlock 方法用于释放锁。自旋锁的性能和适用性取决于具体的应用场景，因此在选择锁的类型时需要谨慎考虑。

锁的性能和可伸缩性​

选择适当类型的锁以满足性能需求是多线程编程的重要方面。不同类型的锁在性能和可伸缩性方面具有不同的特点。在某些情况下，使用过多的锁可能导致性能下降，而在其他情况下，选择错误的锁类型可能会导致竞争和瓶颈。

性能测试和比较是评估锁性能的关键步骤。通过对不同锁类型的性能进行基准测试，开发人员可以更好地了解它们在特定情况下的表现。此外，性能测试还可以帮助确定是否需要调整锁的配置，如并发级别或等待策略。

除了性能外，可伸缩性也是一个关键考虑因素。可伸缩性指的是在增加核心数或线程数时，系统的性能是否能够线性提高。某些锁类型在高度并发的情况下可能会产生争用，从而降低可伸缩性。

因此，在选择锁时，需要根据应用程序的性能需求和并发负载来权衡性能和可伸缩性。一些常见的锁优化策略包括调整并发级别、选择合适的等待策略以及使用分离锁来减小竞争范围。

参考​

最后于 更新