亲宝软件园·资讯

展开

Java悲观锁与乐观锁

小女养成记 人气:0

问题:

1、乐观锁和悲观锁的理解及如何实现,有哪些实现方式?

2、什么是乐观锁和悲观锁?

3、乐观锁可以重入吗?

1. 悲观锁存在的问题

独占锁其实就是一种悲观锁,java的synchronized是悲观锁。悲观锁可以确保无论哪个线程持有锁,都能独占式访问临界区。虽然悲观锁的逻辑非常简单,但是存在不少问题。

悲观锁总是假设会发生最坏的情况,每次线程读取数据时,也会上锁。这样其他线程在读取数据时就会被阻塞,直到它拿到锁。传统的关系型数据库用到了很多悲观锁,比如行锁、表锁、读锁、写锁等。

悲观锁机制存在以下问题:

(1)在多线程竞争下,加锁、释放锁会导致比较多的上下文切换和调度延时,引起性能问题。

(2)一个线程持有锁后,会导致其他所有抢占此锁的线程挂起。

(3)如果一个优先级高的线程等待一个优先级低的线程释放锁,就会导致线程的优先级倒置,从而引发性能风险。

解决以上悲观锁的这些问题的有效方式是使用乐观锁去替代悲观锁。与之类似,数据库操作中的带版本号数据更新、JUC包的原子类,都使用了乐观锁的方式提升性能。

2. 通过CAS实现乐观锁

乐观锁的操作主要就是两个步骤:(1)第一步:冲突检测。(2)第二步:数据更新。

乐观锁一种比较典型的就是CAS原子操作,JUC强大的高并发性能是建立在CAS原子之上的。CAS操作中包含三个操作数:需要操作的内存位置(V)、进行比较的预期原值(A)和拟写入的新值(B)。如果内存位置V的值与预期原值A相匹配,那么处理器会自动将该位置的值更新为新值B;否则处理器不做任何操作。

CAS操作可以非常清晰地分为两个步骤:

(1)检测位置V的值是否为A。

(2)如果是,就将位置V更新为B值;否则不要更改该位置。

CAS操作的两个步骤其实与乐观锁操作的两个步骤是一致的,都是在冲突检测后进行数据更新。

乐观锁是一种思想,而CAS是这种思想的一种实现。实际上,如果需要完成数据的最终更新,仅仅进行一次CAS操作是不够的,一般情况下,需要进行自旋操作,即不断地循环重试CAS操作直到成功,这也叫CAS自旋。通过CAS自旋,在不使用锁的情况下实现多线程之间的变量同步,也就是说,在没有线程被阻塞的情况下实现变量的同步,这叫作“非阻塞同步”,或者说“无锁同步”。使用基于CAS自旋的乐观锁进行同步控制,属于无锁编程的一种实践。

3. 不可重入的自旋锁

自旋锁的基本含义为:当一个线程在获取锁的时候,如果锁已经被其他线程获取,调用者就一直在那里循环检查该锁是否已经被释放,一直到获取到锁才会退出循环。

CAS自旋锁的实现原理为:

抢锁线程不断进行CAS自旋操作去更新锁的owner(拥有者),如果更新成功,就表明已经抢锁成功,退出抢锁方法。如果锁已经被其他线程获取(也就是owner为其他线程),调用者就一直在那里循环进行owner的CAS更新操作,一直到成功才会退出循环。

public class SpinLock implements Lock {
     // 当前锁的拥有者
    private AtomicReference<Thread> owner = new AtomicReference<>();
     @Override
    public void lock() {
        Thread t = Thread.currentThread();
        // 自旋
        while (owner.compareAndSet(null,t)){
            // 让出CPU的时间片
            Thread.yield();
        }
    }
     @Override
    public void unlock() {
        Thread t = Thread.currentThread();
        // 只有拥有者才能获取锁
        if(t==owner.get()){
            // 设置owner为空,这里不需要使用compareAndSet,因为已经通过owner做过线程检查
            owner.set(null);
        }
    }
     // 省略其他代码...
}

上述SpinLock是不支持重入的,即当一个线程第一次已经获取到了该锁,在锁没有被释放之前,如果又一次重新获取该锁,第二次将不能成功获取到,因为自旋后CAS会失败。

4. 可重入的自旋锁

为了实现可重入锁,这里引入一个计数器,用来记录一个线程获取锁的次数。一个简单的可重入的自旋锁的代码大致如下:

public class ReentrantSpinLock implements Lock {
     // 当前锁的拥有者,使用Thread作为同步状态
    AtomicReference<Thread> owner = new AtomicReference<>();
     // 记录一个线程重复获取锁的次数
    private int count = 0;
     // 抢占锁
    @Override
    public void lock() {
        Thread t =  Thread.currentThread();
        // 如果时冲入,增加重入次数后,返回
        if(t==owner.get()){
            count++;
            return;
        }
        // 自旋
        while (owner.compareAndSet(null,t)){
            Thread.yield();
        }
    }
     @Override
    public void unlock() {
        Thread t = Thread.currentThread();
        // 只有拥有者才能释放锁
        if(t==owner.get()){
            // 如果重入次数大于0,减少重入次数后返回
            if(count>0){
                count--;
            }else{
                // 设置拥有者为null
                owner.set(null);
            }
        }
    }
     // 省略其他代码...
}

自旋锁的特点:线程获取锁的时候,如果锁被其他线程持有,当前线程将循环等待,直到获取到锁。线程抢锁期间状态不会改变,一直是运行状态(RUNNABLE),在操作系统层面线程处于用户态。

自旋锁的问题:在争用激烈的场景下,如果某个线程持有锁的时间太长,就会导致其他空自旋的线程耗尽CPU资源。另外,如果大量的线程进行空自旋,还可能导致硬件层面的“总线风暴”。

在争用激烈的场景下,Java轻量级锁会快速膨胀为重量级锁,其本质上一是为了减少CAS空自旋,二是为了避免同一时间大量CAS操作所导致的总线风暴。那么,JUC基于CAS实现的轻量级锁如何避免总线风暴呢?答案是:使用队列对抢锁线性进行排队,最大程度上减少了CAS操作数量。

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!   

加载全部内容

相关教程
猜你喜欢
用户评论