ReentrantLock中lock/trylock/lockInterruptibly方法的区别及源码解析

看了几篇关于这三者区别的文章,但都说的不够具体,自己去读了下源码,大概是清楚了三者的功能,不想了解源码的可以跳到最后看总结。

首先,ReentrantLock类中使用了大量的CAS操作,也就是CompareAndSwap原子操作,依靠硬件保证互斥与同步,然后说下interrupt()方法。每个线程都有一个interrupt标志。当线程在阻塞状态时,如sleep、wait、await(park)、join,此时如果对该进程调用interrupt()方法,该线程会被唤醒、interrupt标志被修改,并抛出InterruptedException异常(一旦捕捉到异常,立刻重置interrupt标志),因此上述的那些方法被要求为必须捕捉异常;当线程在运行中并未进入任何阻塞状态时,则interrupt()操作不会打断线程执行,只会修改该线程interrupt标志,此时可以通过Thread.interrupted()/实例.isInterrupted()查看并作出处理(前者会重置该标志位),通常使用while循环来检查。

一、 lock()方法

使用lock()获取锁,若CAS替换state成功,则直接标记本线程获取到了锁,然后返回。若获取失败,这时先将线程阻塞放入等待队列,然后跑一个for循环(如下代码),parkAndCheckInterrupt方法调用LockSupport.park()使线程进入阻塞状态,当它被被唤醒(前一个节点unpark唤醒or外部interrupt唤醒)时会调用tryAcquire继续尝试竞争锁。如果此时用CAS获取到了锁那么就返回,如果没获取到那么再次放入等待队列,如此循环。其间就算外部调用了interrupt(),循环也会继续走下去。一直到当前线程获取到了这个锁,此时才处理interrupt标志,若有,则执行自我调用 Thread.currentThread().interrupt(),结果如何取决于外层的处理。

    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) { //如果竞争得到了锁
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted; //获取成功返回interrupted标志
               }
                 // 只修改标志位,不做其他处理
                 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) 
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

其中parkAndCheckInterrupt()调用了LockSupport.park(),该方法使用Unsafe类将进程阻塞并放入等待队列,等待唤醒,和await()有点类似。

可以看到循环中检测到了interrupt标记,但是仅做 interrupted = true 操作,直到获取到了锁,才return interrupted,然后处理如下

   public final void acquire(int arg) {
        if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt(); // 执行Thread.currentThread().interrupt()
    }

 

二、 lockInterruptibly()方法

和lock()相比,lockInterruptibly()只有略微的修改,for循环过程中,如果检测到interrupt标志为true,则立刻抛出InterruptedException异常,这时程序便通过异常直接返回到最外层了,由外层继续处理,因此使用lockInterruptibly()时必须捕捉异常。lockInterruptibly()最终执行的方法如下:

    private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return; //获取成功返回
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException(); //直接抛出异常
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

 

三、 tryLock()方法

使用tryLock()尝试获取一次锁,若获取成功,标记下是该线程获取到了锁,然后返回true;若获取失败,此时直接返回false,之后的操作取决于外层,代码如下:

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

 

else if 中的情况属于锁重入情况,即外层函数已经获取到这个锁了,内部的函数又再次对其进行获取,那么对计数器加一,不再循环加锁。

四、tryLock(long timeout, TimeUnit unit) 方法

还有一种情况,即使用tryLock(long timeout, TimeUnit unit)获取锁,此时有点像lockInterruptibly()的升级版,在获取锁失败后的循环中,它被放入等待队列并使用 LockSupport.parkNanos(this, nanosTimeout) 阻塞进程,同时timeout扣减每次循环消耗的时间,当timeout用尽时如果依然没有获取到锁,那么就返回false。对于循环期间收到的interrupt()的处理,这儿和lockInterruptibly()一样,一旦检测到,那么直接抛出异常。代码如下:

    private boolean doAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
        long lastTime = System.nanoTime();
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return true; //获取成功返回
                }
                if (nanosTimeout <= 0)
                    return false;
                if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout); //带timeout的阻塞
                long now = System.nanoTime();
                nanosTimeout -= now - lastTime;
                lastTime = now; // 更新timeout
                if (Thread.interrupted())
                    throw new InterruptedException(); //直接抛出异常
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }

 

总结

  1. lock()  阻塞式地获取锁,只有在获取到锁后才处理interrupt信息
  2. lockInterruptibly() 阻塞式地获取锁,立即处理interrupt信息,并抛出异常
  3. tryLock()  尝试获取一次锁,不管成功失败,都立即返回true、false
  4. tryLock(long timeout, TimeUnit unit)在timeout时间内阻塞式地获取锁,成功返回true,超时返回false,同时立即处理interrupt信息,并抛出异常
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值