Java锁之ReentrantLock源码解析

31 篇文章 0 订阅
16 篇文章 2 订阅

目录

1.ReentrantLock

1.1整体结构

1.2ReentrantLock 构造器

1.3释放锁的源码分析

1.4公平锁源码分析——FairSync类

1.5非公平锁源码解析——NonfairSync类

1.6加锁和尝试加锁——ReentrantLock类

1.7公平和非公平问题;


1.ReentrantLock


1.1整体结构

  • 可重入锁针对同一个线程可以对同一个对象重复获取锁;支持公平和非公平获取锁(tryLock只有非公平性,而lock都有)
  • ReentrantLock 类本身是不继承 AQS 的,实现了 Lock 接口
public class ReentrantLock implements Lock, java.io.Serializable {...}
public interface Lock {
    // 获得锁方法,获取不到锁的线程会到同步队列中阻塞排队
    void lock();
    // 获取可中断的锁
    void lockInterruptibly() throws InterruptedException;
    // 尝试获得锁,如果锁空闲,立马返回 true,否则返回 false
    boolean tryLock();
    // 带有超时等待时间的锁,如果超时时间到了,仍然没有获得锁,返回 false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    // 释放锁
    void unlock();
    // 得到新的 Condition
    Condition newCondition();
}
  • Sync 继承了 AbstractQueuedSynchronizer ,所以 Sync 就具有了锁的框架,Sync 只实现了 AQS 预留的几个方法,还有一些交给子类 NonfairSync 和 FairSync 去实现了,NonfairSync 是非公平锁,FairSync 是公平锁
// 同步器 Sync 的两个子类锁
static final class FairSync extends Sync {...}
static final class NonfairSync extends Sync {...}

1.2ReentrantLock 构造器

// 无参数构造器,相当于 ReentrantLock(false),默认是非公平的
public ReentrantLock() {
    sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

默认是非公平的获取锁

1.3释放锁的源码分析

  • ReentrantLock的sync类实现的尝试释放锁
// 释放锁方法,非公平和公平锁都使用
protected final boolean tryRelease(int releases) {
    // 当前同步器的状态减去释放的个数,releases 一般为 1
    int c = getState() - releases;
    // 当前线程根本都不持有锁,报错
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 如果 c 为 0,表示当前线程持有的锁都释放了
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 如果 c 不为 0,那么就是可重入锁,并且锁没有释放完,用 state 减去 releases 即可,无需做其他操作
    setState(c);
    return free;
}

更新锁的状态,如果状态为0说明当前线程可以直接释放掉锁(因为是可重入的所以需要判断)

  • AQS实现了release方法,该方法底层实际使用的是子类sync实现的tryRelease方法
    // 释放锁
    public void unlock() {
        sync.release(1); //调用AQS的方法
    }
    // AQS的release方法
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)// 还没有一次入队enq方法就为null
                unparkSuccessor(h); // 判断无效节点,然后才进行释放LockSupport.unpark(s.thread);
            return true;
        }
        return false;
    }

unlock方法调用sync的release方法,而release方法是sync继承AQS的,并且底层需要的tryRelease方法还是sync这个子类来实现的。

1.4公平锁源码分析——FairSync类

  • FairSync 公平锁只实现了 lock 和 tryAcquire 两个方法
// acquire 是 AQS 的方法,表示先尝试获得锁,失败之后进入同步队列阻塞等待
final void lock() {
    acquire(1);
}

AQS的acquire默认就是公平的获取锁

// tryAcquire是AQS默认要让子类去实现的方法
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // hasQueuedPredecessors 是实现公平的关键
        // 会判断当前执行线程是不是属于同步队列的头节点的下一个节点
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 可重入锁
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}
public final boolean hasQueuedPredecessors() {
    Node t = tail;
    Node h = head;
    Node s;
    // (s = h.next) == null就是为了赋值而已,一定为false的
    // 判断头节点的next是否正在运行
    return h != t &&   
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

跟nonfairTryAcquire非公平的获取锁,只多了一个是否是队列头节点的下一个节点的判断

先获取锁的状态,如果s=0并且是队列头节点的下一个节点那么就可以获取锁,如果s不为零需要进行可重入,要将锁的状态进行累加

1.5非公平锁源码解析——NonfairSync类

  • NonfairSync 底层实现了 lock 和 tryAcquire 两个方法
// 加锁
final void lock() {
    // cas 给 state 赋值
    if (compareAndSetState(0, 1))
        // cas 赋值成功,代表拿到当前锁,记录拿到锁的线程
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // acquire 是抽象类AQS的方法,
        // 但是tryAcquire需要子类进行重写
        acquire(1);
}
// 直接使用的是 Sync.nonfairTryAcquire 方法 
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}
// 尝试获得非公平锁
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    // 同步器的状态是 0,表示同步器的锁没有人持有
    if (c == 0) {
        // 当前线程持有锁
        if (compareAndSetState(0, acquires)) {
            // 标记当前持有锁的线程是谁
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 如果当前线程已经持有锁了,同一个线程可以对同一个资源重复加锁,代码实现的是可重入锁
    else if (current == getExclusiveOwnerThread()) {
        // 当前线程持有锁的数量 + acquires
        int nextc = c + acquires;
        // int 是有最大值的,<0 表示持有锁的数量超过了 int 的最大值
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    //否则线程进入同步队列
    return false;
}

同步状态是0说明可以直接获取锁,通过cas操作设置状态,线程获取互斥锁

大于0先要判断是不是可冲入,如果当前线程可冲入那么就需要状态累加

其他情况,获取不到锁并且线程进入同步队列

ps:整个过程和公平获取锁大致相同,根本的区别就是公平锁加了判断(node是否前面还有节点)

1.6加锁和尝试加锁——ReentrantLock类

//支持公平和非公平获取锁——FairSync类
public void lock() {
    sync.lock();
}

// 无参构造器——NonfairSync类
// 只支持非公平获取锁
public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}

// timeout 为超时的时间,在时间内,仍没有得到锁,会返回 false
// 调用了sync继承AQS的tryAcquireNanos方法,该方法底层还是调用了tryAcquire是sync子类实现的方法可以实现公平和非公平获取锁
public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

lock:根据构造器决定公平和非公平获取锁,两个sync类都实现了对应的lock方法

tryLock:只支持非公平获取锁,sync类实现了该nonfairTryAcquire方法

带超时的tryLock:支持公平和非公平获取锁,sync继承了AQS的该方法,此方法底层用到了sync两个子类实现的tryAcquire

1.7公平和非公平问题;

  • 当第一个线程抢占了锁没在同步队列放节点,然后接着几个线程抢占那么就会放入同步队列,有时候第一个线程会出现连续进行抢占的;
  • 在非公平情况下,第一个线程因为没在同步队列,只要尝试获取锁成功那么,在释放后先唤醒同步队列的第一个节点,尽管如此第一个线程还是可以继续抢占的,这样可以充分利用cpu,但会出现饥饿的情况;
  • 在公平情况下,第一个线程如果抢占了第二次尝试获取,是不会成功的因为加了判断--当前线程是不是等于同步队列的头节点的下一个节点的线程,所有绝对的公平应该是按照尝试获取锁的时间来判断的,可以避免饥饿;
  • 扩展:不管如何,同步队列是可以保证完全公平的释放节点的;
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值