Java并发 - Java中所有的锁

发布时间:2024年01月03日

Java 中提供了多种锁机制,用于实现多线程之间的同步和互斥。
在这里插入图片描述

1. 乐观锁&悲观锁

1.1 特点

乐观锁:假定多个事务之间很少发生冲突,操作不加锁。发生错误的时候进行回滚或重试。

悲观锁:假定冲突可能频繁发生,先加锁,阻止其他事务发生,操作后释放锁。

实现机制

乐观锁:实现方式是利用版本号(versioning)或时间戳(Timestamp),在进行更新的时候检查版本号或时间戳是否仍然匹配。

悲观锁:使用传统的锁机制,如synchronize 关键字或 ReetrantLock,执行完成释放锁

1.2 性能
  • 乐观锁:适合读多写少,在高并发写入的情况下,可能出现多次重试,导致性能降低。

  • 悲观锁:时候写多读少,在高并发写入的情况下,可能会有较多的线程竞争,导致性能降低。

1.3 示例

乐观锁:

AtomicInteger version = new AtomicInteger();

public void updateData(Object newData){
    int currentVersion = version.get();
    if (currentVersion == version.get()){
        // 执行更新
        update(newData);
        // 增加版本
        version.incrementAndGet();
    }else {
        throw new OptimisticLockingFailureException("concurrent modification detected");
    }
}

悲观锁:

// 使用ReentrantLock实现悲观锁
ReentrantLock lock = new ReentrantLock();

// 更新操作
public void updateData(Object newData) {
    lock.lock(); // 获取锁
    try {
        // 执行更新
        update(newData);
    } finally {
        lock.unlock(); // 释放锁
    }
}

2. 自旋锁 & 适应性自旋锁

自旋锁(Spin Lock)和适应性自旋锁是两种不同的锁实现,用于在多线程环境中同步访问共享资源。

2.1 特点

自旋锁:

  • 一直自旋,当线程尝试获取锁,如锁已被其他线程占用,一直自旋等待直到获取到锁为止。
  • 不考虑等待时间。

适应性自旋锁:

  • 动态自适应,根据锁的历史信息进行动态调整自旋时间。
  • 考虑等待时间。

优点:

自旋锁:低开销,自旋锁通常比较轻量,适用于锁竞争不激烈的情况。

适应性自旋锁:适应性 ,适应性自旋锁能够在锁的竞争激烈时自适应地减少自旋等待时间,提高效率。

缺点:

自旋锁:高竞争下效率低,在锁竞争激烈的情况下,自旋会导致线程不断自旋,浪费 CPU 资源。

适应性自旋锁:复杂性 ,实现适应性自旋锁的算法较为复杂,可能会引入一些额外的开销。

2.2 性能
  • 自旋锁: 适用于锁竞争不激烈的情况,且期望锁的开销较小。

  • 适应性自旋锁:适用于锁的竞争激烈、存在较多争用的情况,能够根据实际情况调整自旋等待时间。

2.3 示例

自旋锁

import java.util.concurrent.atomic.AtomicReference;

public class SpinLock {
    private AtomicReference<Thread> owner = new AtomicReference<>();

    public void lock() {
        Thread currentThread = Thread.currentThread();
        while (!owner.compareAndSet(null, currentThread)) {
            // 自旋等待
        }
    }

    public void unlock() {
        Thread currentThread = Thread.currentThread();
        owner.compareAndSet(currentThread, null);
    }
}

适应性自旋锁

见 JDK 并发包中的 ReentrantLock

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

这四种锁结构都是针对synchronized来说的。锁的升级是由于竞争的激烈程度导致的,竞争越大,锁结构越重量化。

锁升级实现流程实现
在这里插入图片描述

3.1 特点

无锁: 不使用任何锁机制,通过一些算法或硬件原语实现多线程间的同步,通常在并发度较高的情况下表现优越。

偏向锁: 当一个线程访问同步块并获取锁时,会在对象头上的Mark Word中记录锁偏向的线程ID,以后该线程在进入和退出同步块时不需要进行额外的操作。

轻量级锁: 当一个线程尝试获取锁时,如果没有竞争,将在对象头的Mark Word中存储指向锁记录的指针;如果有竞争,会膨胀为重量级锁。

重量级锁: 当一个线程尝试获取锁时,如果存在竞争,将通过操作系统的互斥原语(如操作系统的 Mutex)来实现锁。

优点:

无锁:无竞争开销: 适用于低竞争、高并发的情况,减少锁的开销。

偏向锁:减少竞争: 适用于大多数情况下都是单线程访问同步块的场景,减少无谓的竞争。

轻量级锁:低竞争: 适用于线程间竞争不激烈的情况,减少了传统重量级锁的性能开销。

重量级锁:适应高竞争: 在多线程间存在激烈竞争的情况下,重量级锁能够确保线程安全。

缺点:

无锁:复杂性: 无锁算法相对复杂,实现较为困难。

偏向锁:切换成本: 如果存在多线程竞争,会导致锁膨胀为轻量级锁,引入额外的切换成本。

轻量级锁:自旋等待: 线程可能会进行短暂的自旋等待,一旦竞争激烈,可能会升级为重量级锁。

重量级锁:性能开销: 在竞争激烈的情况下,频繁地切换锁的所有者,可能导致性能下降。

3.2 性能
  • 无锁: 适用于高并发度、低竞争的场景,算法实现较为复杂。
  • 偏向锁: 适用于单线程频繁访问同步块的场景,减少无谓的竞争。
  • 轻量级锁: 适用于线程间竞争不激烈的情况,减少了传统重量级锁的性能开销。
  • 重量级锁: 适用于多线程竞争激烈、需要确保线程安全的场景,但可能会引入较大的性能开销。

4. 公平锁 & 非公平锁

锁可以分为公平锁和非公平锁,它们主要区别于获取锁的顺序。

公平锁 / 非公平锁:

前提:已存在多个线程在排队获取锁,存在阻塞队列。

条件:新来一个线程需要获取资源。

公平锁:在阻塞队列后面排队。

非公平锁:先竞争锁,竞争失败了才到阻塞队列后面排队。

4.1 特点
  • 公平锁

    • 获取锁顺序: 公平锁按照请求锁的顺序获取锁,即先到先得的原则。
    • 等待队列: 线程在等待锁时会进入一个先进先出(FIFO)的等待队列。
    • 实现机制: 公平锁通常使用队列(如 ReentrantLock 中的 FairSync)来维护等待队列。
  • 非公平锁

    • 获取锁顺序: 非公平锁在尝试获取锁时不考虑等待队列中其他线程的顺序,可能会插队成功获取锁。
    • 等待队列: 线程在等待锁时可能会插队直接获取锁,不一定按照请求的顺序。
    • 实现机制: 非公平锁通常使用一种较为简单的机制,避免了公平锁的性能开销。

优点

公平锁:公平性: 所有线程都有机会获取锁,不会出现饥饿现象。

非公平锁:性能: 在高并发的情况下,非公平锁通常具有更好的吞吐量,因为它允许线程插队。

缺点

公平锁:性能开销: 实现公平锁通常需要维护一个等待队列,可能引入额外的性能开销。

非公平锁:可能导致饥饿: 一些线程可能会被其他线程一直插队,导致某些线程一直无法获取锁,可能会出现饥饿现象。

4.2 性能
  • 公平锁: 由于需要维护等待队列,可能在高并发场景下性能相对较低。
  • 非公平锁: 通常具有更好的吞吐量,因为它允许一些线程插队,降低了竞争。
4.3 示例
ReentrantLock fairLock = new ReentrantLock(true); // 公平锁
ReentrantLock unfairLock = new ReentrantLock(false); // 非公平锁

5. 可重入锁 & 非可重入锁

锁可以分为可重入锁和非可重入锁,它们主要区别于同一个线程是否可以多次获得同一个锁。

ReentrantLocksynchronized 关键字都是可重入锁的实现。

5.1 特点
  • 可重入锁

    • 可重入性: 同一个线程可以多次获得同一个锁,每次获得锁都会给锁计数器加1,需要相同次数的释放操作才能释放锁。
    • 递归调用: 在递归调用中,线程不会被自己持有的锁所阻塞。
    • 实现机制: Java 中的 ReentrantLocksynchronized 关键字都是可重入锁的实现。
  • 非可重入锁

    • 不可重入性: 同一个线程获得锁后,再次尝试获得时会被阻塞,造成死锁。
    • 不支持递归调用: 在递归调用中,线程会被自己持有的锁所阻塞,无法再次获取。

6. 独享锁(排他锁) & 共享锁

锁可以分为独享锁(排他锁)和共享锁,它们主要用于多线程之间对共享资源的访问控制

6.1 特点
  • 独享锁

    • 获取方式: 独享锁是一种独占式的锁,一次只能被一个线程持有。
    • 互斥性: 当一个线程持有独享锁时,其他线程无法获取该锁,需要等待释放。
    • 操作原子性: 独享锁通常用于保护临界区或关键代码段,确保操作的原子性。
  • 共享锁

    • 获取方式: 共享锁是一种共享式的锁,可以被多个线程同时持有。
    • 允许并发: 多个线程可以同时获取共享锁,允许并发读取共享资源。
    • 读写分离: 共享锁通常用于读多写少的场景,提高读操作的并发性。

优点

独享锁:数据安全: 适用于需要保护临界区或写操作的场景,确保数据的一致性和完整性。

共享锁:高并发: 适用于读操作较多的场景,能够提高系统的并发性。

缺点

独享锁:竞争激烈: 在高并发场景下,独享锁的竞争可能较为激烈,导致性能下降。

共享锁:不适用于写操作: 对于写操作,需要等待其他线程释放共享锁,可能导致写操作的延迟。

6.2 性能
  • 独享锁: 适用于需要保护临界区或关键代码段,确保操作的原子性,写操作较为频繁的场景。
  • 共享锁: 适用于读操作较为频繁的场景,提高系统的并发性,对数据的一致性要求相对较低。
6.3 示例
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

// 共享锁
public int readData() {
    readWriteLock.readLock().lock(); // 获取读锁
    try {
        System.out.println(Thread.currentThread().getName() + " is reading data: " + data);
        return data;
    } finally {
        readWriteLock.readLock().unlock(); // 释放读锁
    }
}

// 独享锁
public void writeData(int newData) {
    readWriteLock.writeLock().lock(); // 获取写锁
    try {
        System.out.println(Thread.currentThread().getName() + " is writing data: " + newData);
        data = newData;
    } finally {
        readWriteLock.writeLock().unlock(); // 释放写锁
    }
}


文章来源:https://blog.csdn.net/qq_43678225/article/details/135293685
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。