【线程】ReentrantLock 源码剖析 （八）

已于 2023-04-15 16:57:43 修改
阅读量264 收藏
点赞数 3
分类专栏： 线程 文章标签： Reentrantlock 源码 公平锁非公平锁 java 线程
于 2019-09-11 00:28:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sword52888/article/details/100538270
版权

我的原则：先会用再说，内部慢慢来

文章目录

一、竞争锁的场景

  1. 只有一个线程：
    1.1. threadA 首次直接成功 lock
    1.2. threadA 重入
  2. 存在多个线程竞争（假设2个线程，threadA + threadB： threadA 目前持有锁，threadB 准备来抢 lock）
    2.1 threadB进入等待队列后，发现threadA 还没干完活，threadB 阻塞
    2.2 threadB进入等待队列后，发现threadA 已经干完活来，threadB 直接拿到

在这里插入图片描述

二、代码Hirerachy结构

在这里插入图片描述

架构代码：

public class ReentrantLock implements Lock, java.io.Serializable {
    private final Sync sync;
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    
    abstract static class Sync extends AbstractQueuedSynchronizer {}
    static final class NonfairSync extends Sync {}
    static final class FairSync extends Sync {}
}

三、相关对象展示

ReentrantLock lock = new ReentrantLock();
  1. ReentrantLock
public class ReentrantLock implements Lock, java.io.Serializable {
    private final Sync sync;

    /**
     * ======================  抽象静态内部类 sync  ======================  
     **/	
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
        abstract void lock();
        final boolean nonfairTryAcquire(int acquires){}
        protected final boolean tryRelease(int releases) {}
        protected final boolean isHeldExclusively() {}
        final ConditionObject newCondition() {}
        final Thread getOwner() {}
        final int getHoldCount() {}
        final boolean isLocked() {}
        private void readObject(java.io.ObjectInputStream s){}
    }

    /**
     * ======================  公平锁与非公平锁实现抽象静态内部类 sync  ======================  
     **/
    static final class NonfairSync extends Sync {
        final void lock() {}
        protected final boolean tryAcquire(int acquires) {}
    }
    
    static final class FairSync extends Sync {
        final void lock() {}
        protected final boolean tryAcquire(int acquires) {}
    }

    /**
     * ======================  ReentrantLock 构造方法  ======================  
     **/
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    /**
     * ======================  ReentrantLock 下面的几个方法都是基于 sync  ======================  
     **/
    public void lock() {
        sync.lock();
    }
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
    public void unlock() {
        sync.release(1);
    }
    public Condition newCondition() {
        return sync.newCondition();
    }
    public int getHoldCount() {
        return sync.getHoldCount();
    }
    public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }
    public boolean isLocked() {
        return sync.isLocked();
    }
    public final boolean isFair() {
        return sync instanceof FairSync;
    }
	protected Thread getOwner() {
        return sync.getOwner();
    }
    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }
    public final boolean hasQueuedThread(Thread thread) {
        return sync.isQueued(thread);
    }
    public final int getQueueLength() {
        return sync.getQueueLength();
    }
    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }
    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
    }
    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
    }
    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
    }
}
  1. AbstractQueuedSynchronizer

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer implements java.io.Serializable {
    private transient volatile Node head;
    private transient volatile Node tail;
    private volatile long state;
    
    static final class Node {
        static final Node SHARED = new Node(); //共享模式
        static final Node EXCLUSIVE = null; // 独占模式
        static final int CANCELLED =  1 （处于取消的等待状态。因为超时或中断就会处于该状态，并且处于该状态的节点不会转变为其他状态处于该状态的节点不会再次被阻塞）
        static final int SIGNAL    = -1;（等待状态。表示后继节点是否需要被唤醒）
        static final int CONDITION = -2;（Condition状态。该节点处于条件队列当中，该节点不会用作同步队列直到设置状态0用来传输时才会移到同步队列当中，并且加入对同步状态的获取）
        static final int PROPAGATE = -3;（迭代状态。表示下一次共享式同步状态获取将会无条件地传播下去）  
        volatile int waitStatus; // 等待状态
        volatile Node prev; //前驱指针
        volatile Node next; // 后继指针
        volatile Thread thread; //当前Node指向的thread
        Node nextWaiter; // 这个当 EXCLUSIVE 的时候，始终是null。它使用在 Condtion中

        final boolean isShared() {
            return nextWaiter == SHARED;
        }
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
        Node() {    // Used to establish initial head or SHARED marker
        }
        Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }
        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }
}
  1. AbstractOwnableSynchronizer
@Data
public abstract class AbstractOwnableSynchronizer
    implements java.io.Serializable {
    	private transient Thread exclusiveOwnerThread;
}

四、lock 源码 ，根据场景剖析加锁 （以非公平锁为例）

1.1 threadA 首次直接成功 lock
class NonfairSync extends Sync {
    final void lock() {
        //  必须在队列为空的情况下，才能执行这个操作。CAS 设置状态 1
        if (compareAndSetState(0, 1))
            // 获取到lock了，当前线程设置为独占线程
            setExclusiveOwnerThread(Thread.currentThread());//AbstractOwnableSynchronizer#setExclusiveOwnerThread 
            /*
                ========  1.1. 首次直接成功 lock  ，程序跑到这里，不往下走了 ========
             */
        else
            // 获取不到锁，走这里
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

在这里插入图片描述

1.2 threadA 重入

当前 lock.state >= 1,并且lock.currentThread = this， 走acquire(1)

  • 看下 acquire 方法：
void AbstractQueuedSynchronizer#acquire(int arg) {
    
	 // 下面 &&符号表示： tryAcquire 获取不到锁的时候，才继续往下走
    if (!tryAcquire(arg) &&
	     /*
	      ======== 1.2. 重入成功 lock ，程序跑到这里 tryAcquire 返回，不往下走了========
	     */
          /*
           ======== 2.1. 同一个 lock  对象，thread1 拿住了这个lock，thread2 准备来抢夺 ========
          */
         // 下面有俩方法： AbstractQueuedSynchronizer#acquireQueued 与 AbstractQueuedSynchronizer#addWaiter

        acquireQueued(
            // Node EXCLUSIVE = null
            addWaiter(Node.EXCLUSIVE), arg)
        )
        selfInterrupt();
}
  • 看下 tryAcquire 方法：
protected boolean tryAcquire(int arg) {
          throw new UnsupportedOperationException();
}

AbstractQueuedSynchronizer#tryAcquire 必须后续实现，现在看 NonSync#tryAcquire

boolean NonfairSync#tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}
  • 看下 nonfairTryAcquire 方法：
boolean Sync#nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    // 获取 state，未设置，默认是 0
    int c = getState();
    // 1.2. 重入成功 c >=1 , 不走下面的if
    if (c == 0) {
        // CAS 设置状态，跟上面的 NonfairSync#lock() 方法其实是有代码冗余
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            // 获取到锁，返回true，非重入。外面acquire就不往下走了
            return true;
        }
    }
    // 1.2. 重入成功 c >=1 , 跳过上面的if ，状态+1
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        // 获取到锁，返回true，重入。外面acquire就不往下走了
        return true;
    }
    return false;
}

2.1 threadB进入等待队列后，发现threadA 还没干完活，threadB 阻塞
acquireQueued(
    addWaiter(Node.EXCLUSIVE), arg)   // NodeEXCLUSIVE = null
)
  • 看 addWaiter 方法
Node AbstractQueuedSynchronizer#addWaiter(Node mode) {
    // Node.EXCLUSIVE = null
    Node node = new Node(Thread.currentThread(), mode);
    // 一开始 tail = null , 所以 pred 也是 null
    Node pred = tail;
   /*
        1. 等待队列里面最少有一个Node，Node 加入到队列后面。
        2. 等待队列里面一个Node都没有，那么 pred = null ，直接 enq(node)
     */
    if (pred != null) {
        node.prev = pred;
        // 将新进来的 Node 接到队列最后面
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            // 返回传进来的节点
            return node;
        }
    }
    /*
      	enq 进队列，
      	1. 队列是空 ：创建队列，也就是整个队列都没Node的时候
      	2. 队列不为空：那么跑到这一步的原因是上面setTail失败了，也就是该node本该插入到队列末端，但是没有。因为其他线程已经领先执行该操作了。为了继续往队列的尾巴插入，调用了 enq方法。
      */
    enq(node);
    // 返回准备入队列的 node
    return node;
}

AbstractQueuedSynchronizer.Node#Node(Thread thread, Node mode){     // Used by addWaiter
    this.nextWaiter = mode;
    this.thread = thread;
}
  • 看 enq 方法
Node AbstractQueuedSynchronizer#enq(final Node node) {
    for (;;) {
        /*
	        1. 队列里面是空： 
	            1.1 for 第一次循环  tail = null, 所以 t = null;
	            1.2 for 第二次循环 t = tail，tail 这个时候指向了 new Node(),所以 t 指向了 new Node()
	        2.  队列不为空，里面只一个有 NodeB
	        	2.1 for CAS操作，把NodeC 插入到 NodeB 后面
         */
        Node t = tail; 
        if (t == null) { 
            // CAS 设置 head 指针，head 指向 new Node()
            if (compareAndSetHead(new Node()))
                // tail 也指向 new Node()
                tail = head;
        } else {
            /*
            	1. 队列里面是空： 
                	1.1 初始化head和tail后，第二次 for 的时候进入了。
                	1.2. 现在准备入队列的 node 的前指针 prev 指向了 t，也就是 new Node()
                2. 队列不为空，只一个有 NodeB，那么NodeC 插在NodeB的后面
             */
            node.prev = t;
            // CAS 设置 tail 指向了准备入队列的 node，如果插入失败就下个for继续插入。
            if (compareAndSetTail(t, node)) {
                // t 的后指针 next 指向了 node
                t.next = node;
                // node前面的一个node返回，最前面是Node new，这个enq方法的返回值在 addWaiter 这一步骤没被使用。
                return t;
            }
        }
    }
}

在这里插入图片描述

  • 看 acquireQueued 方法：

boolean AbstractQueuedSynchronizer#acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            /*
                AbstractQueuedSynchronizer.Node#prev
                1. 当 queue里面只有 new node + 当前 nodeB 的时候，
                p = prev 指向了 new node ，和 head一样，所以进入下面的方法。
             */
            final Node p = node.predecessor();
            /*  
                tryAcquire :
                    1. true 表示刚刚占据lock的threadA，已经处理完毕释放了lock ，this是threadB，现在有机会获取锁了。（debug的时候出现几率多，因为停留太长时间了，threadA已经搞完事情了）
                    2. false 表示刚刚占据lock的threadA现在还占用着，所以走 shouldParkAfterFailedAcquire 
            */
            // 2.2 前驱p是head才可以尝试去 tryAcquire 获取锁，否则只能走下面去进队列阻塞
            if (p == head && tryAcquire(arg)) {
                // head 指向nodeB，释放 nodeB 的前驱指针 prev nodeNew
                setHead(node);
                
                p.next = null; // help GC p == head指向的临时节点 new Node() 的后驱指针next指到 null
                failed = false;
                // return false，外面不往下走了
                return interrupted;
            }
            // 2.1 threadB 阻塞等待拿 lock
            // tryAcquire 返回 false ，第一次循环进入 shouldParkAfterFailedAcquire 返回了 false， pred指向的Node(new) ，waitStatus 从 0 变成了 1
            if (shouldParkAfterFailedAcquire(p, node) &&
                /*
                    tryAcquire 返回 false , pred指向的Node(new) 的 ，waitStatus现在是1了，shouldParkAfterFailedAcquire 返回了 true。
                    可以进入 parkAndCheckInterrupt ，这个方法会一直阻塞，直到拿到 lock,
                    LockSupport.park(this) 会阻塞线程，直到被叫醒： unlock的时候，LockSupport.unpark(s.thread);
                 */
                 // 如果线程在这里被打断，那么无所谓，只是标记一下，然后重新进入 for 循环去获取锁，拿不到继续阻塞。
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

  • ===== 场景2.1 ===== 进入下面代码段

  • 看下代码段 (2.1 threadB 阻塞等待拿 lock 走到了这里 )

if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;


boolean AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire(Node pred, Node node) {
        // 前驱指针的状态，此时应该是 new node()，waitStatus初始化默认是 0 
        int ws = pred.waitStatus;
        //状态为-1，表示后继节点已经处于waiting等待状态，等该节点释放或取消，就会通知后继节点
        if (ws == Node.SIGNAL)
            return true;
        //如果状态大于0--取消状态，就跳过该节点循环往前找，找到一个非cancel状态的节点
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            //赋值pred的后继节点为node节点
            pred.next = node;
        } else {  //如果状态小于0
            //必须是PROPAGATE或者0--表示无状态，当是-2的时候，在condition queue队列当中
            //通过CAS设置pred节点状态为signal
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
  • 看下 parkAndCheckInterrupt 方法：

能跑到这里说明shouldParkAfterFailedAcquire返回了true，也就是 pred.waitStatus = Node.SIGNAL，也就是后继节点需要被唤醒。successor’s thread needs unparking

boolean AbstractQueuedSynchronizer#parkAndCheckInterrupt() {
	//通过LockSupport工具阻塞当前线程
    LockSupport.park(this);
    return Thread.interrupted();
}

void LockSupport#park(java.lang.Object)(Object blocker) {
    Thread t = Thread.currentThread();
    setBlocker(t, blocker);
    UNSAFE.park(false, 0L); // 这个地方调用系统方式，直接阻塞停下来，等待 unpark
    setBlocker(t, null);
}

void LockSupport#setBlocker(Thread t, Object arg) {
    // Even though volatile, hotspot doesn't need a write barrier here.
    UNSAFE.putObject(t, parkBlockerOffset, arg);
}
  • 再来一个 NodeC，直接插入到NodeB 后面

在这里插入图片描述
自此， ===== 场景2.1 ===== 分析完毕。

2.2 threadB进入等待队列后，发现threadA 已经干完活了，threadB 直接拿到

threadB 进入的时候，首先进入阻塞。然后 threadA 跑完了,threadB tryAcquire 拿到锁，返回

  1. ===== addWaiter===== 方法threadB没拿到锁，进入 acquireQueued方法
  2. ===== acquireQueued 方法 ===== 在内部的 ===== tryAcquire 方法 ===== 拿到了锁
if (p == head && tryAcquire(arg)) {
       // head 指向nodeB，释放 nodeB 的前驱指针 prev nodeNew
       setHead(node);
       
       p.next = null; // help GC p == head指向的临时节点 new Node() 的后驱指针next指到 null
       failed = false;
       // return false，外面不往下走了
       return interrupted;
}
  • 看下 setHead 方法：

void AbstractQueuedSynchronizer#setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}

若是NodeB 进来，那么NodeB 的当前thread就变成了 null了，他变成头节点了。因为刚刚threadB 在tryAcquire 的时候已经获取到锁了。

在这里插入图片描述
在这里插入图片描述
自此， ===== 场景2.2 ===== 分析完毕。

五、unlock源码（以非公平锁为例）

场景： threadB，threadC 正在阻塞，threadA干完了，准备unlock
在这里插入图片描述

  • 看下代码 lock.unlock
void ReentrantLock#unlock() {
    sync.release(1);
}

boolean AbstractQueuedSynchronizer#release(int arg) {
    if (tryRelease(arg)) {
        /*
         在没有重入的情况下， tryRelease 返回 true，往下走
        */
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

boolean ReentrantLock.Sync#tryRelease(int releases) {
    int c = getState() - releases;
    // 只有获取锁才有资格释放锁，否则抛异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    /*
         在没有重入的情况下， getState() == 0，c = 0
    */
    if (c == 0) {
        free = true;
        // 清空参数
        setExclusiveOwnerThread(null);
    }
    /*
         在没有重入的情况下， c = 0
    */ 
    setState(c);
    return free;
}
  • 看下 AbstractQueuedSynchronizer#unparkSuccessor 方法

void AbstractQueuedSynchronizer#unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     *
     * 1. unpark的thread正常的话是 head的下一个节点，目前就是 NodeNew的下一个节点。
     * 2. 但是如果Node的等待状态被取消cancelled（一般是lock.lock(10)，等待时间到了），或者是 node == null，
     * 那么会从 tail 开始往前面找，找到 waitStatus <= 0 的节点。
     */
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}
  1. threadA unlock方法之后，释放锁：
    在这里插入图片描述
  2. threadB 被唤醒，去拿锁。
    ===== acquireQueued 方法 ===== 在内部的for 循环 拿到了锁

在这里插入图片描述
在这里插入图片描述

========= 流程跑完 =========

六、lockInterruptibly 源码剖析

  • 看下 lockInterruptibly 方法
public void ReentrantLock#lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

public final void AbstractQueuedSynchronizer#acquireInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);
}
  • 看下 doAcquireInterruptibly 方法
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())
                // 	区别就在这，lock.lock() 方法的话，只是在这里标志一下 interrupt = true，然后继续进入for循环去拿锁，然后继续阻塞，但是 doAcquireInterruptibly 这个时候会抛异常，暂停阻塞。
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

看下图，就这么一个区别，就是被interrupt的时候，接下去如何应对。
在这里插入图片描述

七、trylock 源码剖析

1. tryLock()
public boolean ReentrantLock#tryLock() {
    return sync.nonfairTryAcquire(1);
}

走的是 nonfairTryAcquire 方法 ，那么就只有一次获取锁的机会，要么成功，要么失败，不进入队列。

2. tryLock(long, java.util.concurrent.TimeUnit)
  • 看下 trylock 方法
boolean ReentrantLock#tryLock(long timeout, TimeUnit unit)throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
  • 看下 tryAcquireNanos 方法
public final boolean AbstractQueuedSynchronizer#tryAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    return tryAcquire(arg) ||
        doAcquireNanos(arg, nanosTimeout);
}

private boolean AbstractQueuedSynchronizer#doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
    if (nanosTimeout <= 0L)
        return false;
    final long deadline = System.nanoTime() + nanosTimeout;
    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;
            }
            nanosTimeout = deadline - System.nanoTime();
            if (nanosTimeout <= 0L)
                return false;
            if (shouldParkAfterFailedAcquire(p, node) &&
                nanosTimeout > spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            if (Thread.interrupted())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

看图对比一下 acquireQueued 方法和 doAcquireNanos 方法：
区别1 就在 doAcquireNanos 方法，接受打断Interrupt，这一点跟 lockInterruptibly 一样
区别2 就在 doAcquireNanos内部 LockSupport.parkNanos(this, nanosTimeout); 指定了阻塞时间。等被唤醒或者自动醒来的时候，如果被打断，那么抛异常，没被打断就重新进入 for循环，如果时间到了，那么直接return false，表明没拿到锁。
在这里插入图片描述

3. .LockSupport#park 解析

LockSupport.park() 是一个静态方法，可以用于让当前线程挂起（即阻塞当前线程），在挂起期间，线程将处于休眠状态，不会占用 CPU 资源。

  • 退出时机如下：
    1、调用该方法的线程被中断、
    2、调用 unpark(Thread.thread) 方法并指定当前线程为参数、
    3、使用 parkNanos(long nanos) ，指定挂起时间，时间到了，就会唤醒

八、番外篇

下一章节：【线程】ReentrantLock + Condition 源码剖析 （九）
上一章节：【线程】ReentrantLock 实战 （七）

JebLin02
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java多线程Day18-JUC锁之独占锁ReentrantLock
攻城狮Chova的博客
12-07 349
独占锁ReentrantLock基本概念ReentrantLock函数列表ReentrantLockgetHoldCountgetOwnergetQueuedThreadsgetQueueLengthgetWaitingThreadsgetWaitQueueLengthhasQueuedThreadhasQueuedThreadshasWaitersisFairisHeldByCurrentThreadisLockedlocklockInterruptiblynewConditiontryLockunloc
ReentrantLock（二）：正确使用Condition实现等待与通知
三叶初秋的博客
04-26 8424
关键字synchronized与wait()和notify()/notifyAll()方法相结合可以实现等待/通知模式。 类ReentrantLock同样可以实现该功能，但是要借助于Condition对象。它具有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象里面可以创建多个Condition(对象监视器)实例，线程对象可以注册在指定Condition中，从而有选择性的进行线程通知
Redission的tryLock源码分析
jaaccck的博客
03-28 686
其中的 scheduleExpirationRenewal()方式来更新锁超时时间。
可重入锁ReentrantLock源码解读
小小本科生
01-24 905
ReentrantLock基于AQS，在并发编程中它可以实现公平锁和非公平锁来对共享资源进行同步。同时，和synchronized—样，ReentrantLock支持可重入。除此之外，ReentrantLock在调度上更灵活，支持更多丰富的功能。在Java SE 5 之后，并发包中新增了Lock接口用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要显示地获取和释放锁。Lock的意义在于提供了区别于synchronized的另一种具有更多广泛操作的同步方式。
ReentrantLock（重入锁）tryLock()、unLock()源代码详细学习笔记
Hollake的博客
05-09 1711
前言 前几天学习了解了AQS也叫列同步器AbtstractQueuedSynchronizer的相关源码，今天静下心学习了看了看重入锁的相关源码，在看这篇文章之前希望你可以对ASQ有一定的了解，因为AQS是实现重入锁，读写锁等等的关键，这是自己的学习AQS的链接Java并发AQS队列同步器源码学习笔记，如果不想看的话可以看这篇Java并发之AQS详解，写的很好。在这篇文章中我主要讲一下对重入锁主...
[隐匿撕源码] 从ReentrantLock剖析AQS
01-20
想写一个系列【隐匿撕源码】 剖析各种经典框架，工具，JDK的源码提升自己，同时给大家分享一些心得。这篇文章就作为开端，干就完事了。 从ReentrantLock开始 ReentrantLock 是JDK给我们提供的显示锁 在功能上远远...
ReentrantLock源码详解--条件锁
08-25
主要介绍了ReentrantLock源码之条件锁，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面我们来一起学习一下吧
Java多线程 ReentrantLock互斥锁详解
08-25
主要介绍了Java多线程 ReentrantLock互斥锁详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
ReentrantLock源码解析（二）
12-21
1.1 AQS源码解析 https://blog.csdn.net/qq_34125999/article/details/105343472 1.2 Sync /** * ReentrantLock 基础结构 */ abstract static class Sync extends AbstractQueuedSynchronizer { private static ...
ReentrantLock源码分析
12-26
近日，阅读jdk并发包源码分析整理笔记。
Java 源码 - ReentrantLock 源码解析
热门推荐
简单记录一下。
09-30 20万+
不啰嗦，我们直接开始！ 引导语 上两小节我们学习了 AQS，本章我们就要来学习一下第一个 AQS 的实现类：ReentrantLock，看看其底层是如何组合 AQS ，实现了自己的那些功能。 本章的描述思路是先描述清楚 ReentrantLock 的构成组件，然后使用加锁和释放锁的方法把这些组件串起来。 1、类注释 ReentrantLock 中文我们习惯叫做可重入互斥锁，可重入的意思是同一个线程可以对同一个共享资源重复的加锁或释放锁，互斥就是 AQS 中的排它锁的意思，只允许一个线程获得锁。
Redission-tryLock()源码解析
天地孤影任我行的博客
07-06 4754
Redisson的加锁方法有两个，tryLock和lock，使用上的区别在于tryLock可以设置锁的过期时长leaseTime和等待时长waitTime，核心处理的逻辑都差不多 Redission分布式锁原理_知知之之的博客-CSDN博客_redission实现分布式锁原理原理源码中加锁lua代码if (redis.call('exists', KEYS[1]) == 0) then redis.call('hset', KEYS[1], ARGV[2], 1); redis.call('pexpir
Java并发系列之一 Lock源码解析
weixin_34289744的博客
06-01 202
1. Lock接口简介 Lock接口是Java concurrent包中比较重要的接口。Lock的实现类有ReentrantLock、WriteLock、ReadLock。Lock类中定义了六个方法 void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tr...
java trylock_Java源码阅读之ReentrantLock - lockInterruptibly和tryLock方法
weixin_26643379的博客
02-21 187
阅读优秀的源码是提升编程技巧的重要手段之一。如有不对的地方，欢迎指正转载请注明出处http://www.imooc.com/u/125243。碎碎念上一篇博客阅读了Java的ReentrantLock的lock和unlock，这篇分析另外三个方法lockInterruptibly、tryLock()和tryLock(long time, TimeUnit unit) throws Interrup...
Redis源码分析之tryLock(long waitTime, long leaseTime, TimeUnit unit)
雪落南城的博客
05-13 1万+
RLock的tryLock方法 public boolean tryLock(); public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException; 1、当调用 rLock.tryLock(0,30,TimeUnit.SECONDS)时 源码： ...
ReentrantLock中lock/trylock/lockInterruptibly方法的区别及源码解析
Stay Foolish
08-16 7849
看了几篇关于这三者区别的文章，但都说的不够具体，自己去读了下源码，大概是清楚了三者的功能，不想了解源码的可以跳到最后看总结。 首先，ReentrantLock类中使用了大量的CAS操作，也就是CompareAndSwap原子操作，依靠硬件保证互斥与同步，然后说下interrupt()方法。每个线程都有一个interrupt标志。当线程在阻塞状态时，如sleep、wait、await（park）、...
ReentrantLock源码lock和tryLock区别
小小少年的博客
04-13 527
在reentrantLock中，提供了一个lock和一个tryLock方法，这两个方法是有区别的，这篇笔记主要记录下具体的区别信息 结论 其实对于这个两个方法，简单来说，tryLock()方法，返回的是一个boolean类型变量，返回true，表示加锁成功，返回false，表示加锁失败，但是这个方法是没有排队的功能的 lock()方法有两个功能：尝试加锁 + 排队；所以，lock方法如果加锁失败，会去排队，我们也可以简单的认为，lock = tryLock + 排队方法 lock()源码 lock在加锁的时
tryLock的使用
Mirage__的博客
05-02 1346
tryLock的使用业务场景方法说明用法 业务场景 对于某些并发业务场景，我们可能想保证同一时刻只有一个线程在执行某一方法。 例如：对于缓存的初始化工作，此时我们可以使用tryLock()方法对代码进行上锁，只有拿到锁的线程可以执行操作，而其他线程则只会在进行一次尝试后返回false。 方法说明 Acquires the lock only if it is not held by another thread at the time of invocation. 只有在调用时它是空闲的才能获取锁。 获取锁
【线程】Object.wait 内部原理（二）
Sword52888的博客
08-30 1637
Object.wait 内部原理，剖析到JVM的C++源码。由浅到深
ReentrantLock判断获取锁启动线程
最新发布
01-31
ReentrantLock类提供了两种方法来判断获取锁的启动线程：isHeldByCurrentThread()和getOwner()。 1. isHeldByCurrentThread()方法用于判断当前线程是否持有该锁。如果当前线程持有锁，则返回true；否则返回false。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值