AQS 源码详解

最新推荐文章于 2024-03-11 16:10:23 发布
最新推荐文章于 2024-03-11 16:10:23 发布
阅读量986 收藏 1
点赞数
分类专栏： JVM系列 面试系列 文章标签： 队列 多线程 并发编程 sync AQS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/prefect_start/article/details/115554074
版权

AQS 源码详解

1、可重入锁

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的的内层方法会自动获取锁（前提是锁对象得是同一个对象），不会因为之前已经获取过还没释放而阻塞。

Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。

可重入锁的种类：

  • 隐式锁：在使用的时候不需要去手动释放锁（即synchronized关键字使用的锁）默认是可重入锁。
  • 显式锁：使用的时候需要去释放锁（即Lock）也有ReentrantLock这样的可重入锁。
2、LockSupport

文档地址

LockSupport是一个编程工具类，主要是为了阻塞和唤醒线程用的，它的内部其实两类主要的方法：park（停车阻塞线程）和unpark（启动唤醒线程）。

3种让线程等待和唤醒的方法：

  • 方式1：使用Object中的wait()方法让线程等待，使用object中的notify()方法唤醒线程
  • 方式2：使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程
  • 方式3：LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

park()/park(Object blocker) - 阻塞当前线程阻塞传入的具体线程

public class LockSupport {

    ...
    
    public static void park() {
        UNSAFE.park(false, 0L);
    }

    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }
    
    ...
    
}

permit默认是0，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时，park方法会被唤醒，然后会将permit再次设置为0并返回。

unpark(Thread thread) - 唤醒处于阻塞状态的指定线程

public class LockSupport {
 
    ...
    
    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }
    
    ...

}

调用unpark(thread)方法后，就会将thread线程的许可permit设置成1（注意多次调用unpark方法，不会累加，pemit值还是1）会自动唤醒thead线程，即之前阻塞中的LockSupport.park()方法会立即返回。

3、同样是阻塞、唤醒的方法，park/unpark 和 wait/notify，await/signal有什么区别？
3.1、Object类中的wait和notify方法实现线程等待和唤醒
public class WaitNotifyDemo {

	static Object lock = new Object();
	
	public static void main(String[] args) {
		new Thread(()->{
			synchronized (lock) {
				System.out.println(Thread.currentThread().getName()+" come in.");
				try {
					lock.wait();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName()+" 换醒.");
		}, "Thread A").start();
		
		new Thread(()->{
			synchronized (lock) {
				lock.notify();
				System.out.println(Thread.currentThread().getName()+" 通知.");
			}
		}, "Thread B").start();
	}
}

结论：

  • wait和notify方法必须要在同步块或者方法里面且成对出现使用，否则会抛出java.lang.IllegalMonitorStateException。
  • 调用顺序要先wait后notify才OK。
3.2、Lock锁Condation中的await和singnal方法实现线程等待和唤醒
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionAwaitSignalDemo {
		
	public static void main(String[] args) {
		
		ReentrantLock lock = new ReentrantLock();
		Condition condition = lock.newCondition();
		
		new Thread(()->{
			
			try {
				System.out.println(Thread.currentThread().getName()+" come in.");
				lock.lock();
				condition.await();				
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
			}
			
			System.out.println(Thread.currentThread().getName()+" 换醒.");
		},"Thread A").start();
		
		new Thread(()->{
			try {
				lock.lock();
				condition.signal();
				System.out.println(Thread.currentThread().getName()+" 通知.");
			}finally {
				lock.unlock();
			}
		},"Thread B").start();
	}
	
}

结论：

  • await和singnal必须要在同步块或者方法里面且成对出现使用，否则会抛出java.lang.IllegalMonitorStateException。
  • 调用顺序要先await后singnal才可以。
3.3、LockSupport的park/unpark方法实现线程等待和唤醒

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可（permit），permit只有两个值1和零，默认是零。可以把许可看成是一种(0.1)信号量（Semaphore），但与Semaphore不同的是，许可的累加上限是1。

也就是说，调用LockSupport的park方法时，需要消耗一张许可证，如果没有获取到许可证（也就是permit的值为0）时，就会一直阻塞，等待许可证来进行消耗,如果有许可证可消耗，就会停止阻塞。调用LockSupport的unpark方法，就是生产一份许可证（permint的值加一，由原来的0变为1）。而且许可证的的累加上限是1。

线程阻塞需要消耗凭证(permit)，这个凭证最多只有1个。当调用park方法时，如果有凭证，则会直接消耗掉这个凭证然后正常退出。如果无凭证，就必须阻塞等待凭证可用。而unpark则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效。

public class LockSupportDemo {

	public static void main(String[] args) {
		Thread a = new Thread(()->{
			System.out.println(Thread.currentThread().getName() + " come in. " + System.currentTimeMillis());
			LockSupport.park();
			System.out.println(Thread.currentThread().getName() + " 换醒. " + System.currentTimeMillis());
		}, "Thread A");
		a.start();
		
		Thread b = new Thread(()->{
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			LockSupport.unpark(a);
			System.out.println(Thread.currentThread().getName()+" 通知.");
		}, "Thread B");
		b.start();
	}
}

======================结果=======================
Thread A come in.
Thread B 通知.
Thread A 换醒.

结论：

  • 正常 + 无锁块要求。
  • 先前错误的先唤醒后等待顺序，LockSupport可无视这顺序。
3.4、为什么可以先唤醒线程后阻塞线程？

因为unpark获得了一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞。

3.5、为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程？

因为凭证的数量最多为1（不能累加），连续调用两次 unpark和调用一次 unpark效果一样，只会增加一个凭证；而调用两次park却需要消费两个凭证，证不够，不能放行。

4、AQS

AQS指的是AbstractQueuedSynchronizer 抽象队列同步器。通过内置的FIFO队列来完成资源获取线程的排队工作，以及一个int类型变量表示持有锁的状态。是构建锁或者其它同步器组件的重量级基础框架及整个JUC体系的基石。

在这里插入图片描述

CLH：Craig、Landin and Hagersten队列，是一个单向链表，AQS中的队列是CLH变体的虚拟双向队列FIFO。

4.1、AQS的作用

在这里插入图片描述
在这里插入图片描述
进一步理解锁和同步器的关系

  • 锁，面向锁的使用者 - 定义了程序员和锁交互的使用层APl，隐藏了实现细节，你调用即可
  • 同步器，面向锁的实现者 - 比如Java并发大神DougLee，提出统一规范并简化了锁的实现，屏蔽了同步状态管理、阻塞线程排队和通知、唤醒机制等。

实现了AQS的锁有：自旋锁、互斥锁、读锁写锁、条件产量、信号量、栅栏都是AQS的衍生物。

多个线程共享同一个资源时，同一时刻只有一个线程获取到锁，抢占到资源，抢到资源的线程直接使用处理业务逻辑，抢不到资源的必然涉及一种排队等候机制，抢占资源失败的线程继续去等待但等候线程仍然保留获取锁的可能且获取锁流程仍在继续。

如果共享资源被占用，就需要一定的阻塞等待唤醒机制来保证锁分配。这个机制主要用的是CLH队列的变体实现的，将暂时获取不到锁的线程加入到队列中，这个队列就是AQS的抽象表现。它将请求共享资源的线程封装成队列的结点(Node)，通过CAS、自旋以及LockSupportpark)的方式，维护state变量的状态，使并发达到同步的控制效果。

以Lock lock = new ReentrantLock();

 /** Synchronizer providing all implementation mechanics */
    private final Sync sync;
 /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

ReentrantLock默认是非公平锁，定义了一个最终类Sync来创建非公平锁。NonfairSync继承与Sync类,Sync类又继承于AbstractQueuedSynchronizer。

/**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

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

 /**
     * Base of synchronization control for this lock. Subclassed
     * into fair and nonfair versions below. Uses AQS state to
     * represent the number of holds on the lock.
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();

        /**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        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;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }

        // Methods relayed from outer class

        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {
            return getState() != 0;
        }

        /**
         * Reconstitutes the instance from a stream (that is, deserializes it).
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

AQS使用一个volatile的int类型的成员变量来表示同步状态，通过内置的FIFo队列来完成资源获取的排队工作将每条要去抢占资源的线程封装成一个Node，节点来实现锁的分配，通过CAS完成对State值的修改。

 static final class Node{
 	......
 }
/**
     * Head of the wait queue, lazily initialized.  Except for
     * initialization, it is modified only via method setHead.  Note:
     * If head exists, its waitStatus is guaranteed not to be
     * CANCELLED.
     */
    private transient volatile Node head;

    /**
     * Tail of the wait queue, lazily initialized.  Modified only via
     * method enq to add new wait node.
     */
    private transient volatile Node tail;

    /**
     * The synchronization state.
     */
    private volatile int state;

Lock接口的实现类，基本都是通过聚合了一个队列同步器的子类完成线程访问控制的。
在这里插入图片描述
NonfairSync ，FairSync继承于 Sync类， ReentrantLock 是基于 NonfairSync ，FairSync来实现的，Sync类又继承于AbstractQueuedSynchronizer 。

公平锁与非公平锁抢占锁的区别：

非公平锁：

/**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        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;
        }

公平锁：

/**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                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;
        }
    }

公平锁与非公平锁的lock()方法唯一的区别就在于公平锁在获取同步状态时多了一个限制条件：hasQueuedPredecessors()
hasQueuedPredecessors是公平锁加锁时判断等待队列中是否存在有效节点的方法。
hasQueuedPredecessors() 在AbstractQueuedSynchronizer中

public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

公平锁：公平锁讲究先来先到，线程在获取锁时，如果这个锁的等待队列中已经有线程在等待，那么当前线程就会进入等待队列中;
非公平锁：不管是否有等待队列，如果可以获取锁，则立刻占有锁对象。如果获取不到，再去队列中排队。

在这里插入图片描述

整个ReentrantLock 的加锁过程，可以分为三个阶段：

  • 尝试加锁；
  • 加锁失败，线程入队列；
  • 线程入队列后，进入阻赛状态。

带入一个银行办理业务的案例来模拟我们的AQS 如何进行线程的管理和通知唤醒机制，3个线程模拟3个来银行网点，受理窗口办理业务的顾客。

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class AQSDemo {
	
	public static void main(String[] args) {
		ReentrantLock lock = new ReentrantLock();
		
		//带入一个银行办理业务的案例来模拟我们的AQs 如何进行线程的管理和通知唤醒机制
		//3个线程模拟3个来银行网点，受理窗口办理业务的顾客

		//A顾客就是第一个顾客，此时受理窗口没有任何人，A可以直接去办理
		new Thread(()->{
			lock.lock();
			try {
				System.out.println(Thread.currentThread().getName() + " come in.");
				
				try {
					TimeUnit.SECONDS.sleep(5);//模拟办理业务时间
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} finally {
				lock.unlock();
			}
		}, "Thread A").start();
		
		//第2个顾客，第2个线程---->，由于受理业务的窗口只有一个(只能一个线程持有锁)，此代B只能等待，
		//进入候客区
		new Thread(()->{
			lock.lock();
			try {
				System.out.println(Thread.currentThread().getName() + " come in.");
				
			} finally {
				lock.unlock();
			}
		}, "Thread B").start();
		
		
		//第3个顾客，第3个线程---->，由于受理业务的窗口只有一个(只能一个线程持有锁)，此代C只能等待，
		//进入候客区
		new Thread(()->{
			lock.lock();
			try {
				System.out.println(Thread.currentThread().getName() + " come in.");
				
			} finally {
				lock.unlock();
			}
		}, "Thread C").start();
	}
}

在这里插入图片描述
非公平锁为例进入源码: 首先是运行线程A,

    public void lock() {
        sync.lock();
    }

/**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

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

线程A进入，先调用lock()方法，获取锁，此时state(锁的同步状态)处于初始状态，即为0，然后进行判断比较，使用的是compareAndSetState（）方法，CAS的思想，底层实现是unsafe类，比较锁状态的期望值和预计值是否相同，相同则更新状态1，接着设置当前线程为独占的所有者线程。线程A占用锁成功，更改锁同步的状态为1，开始处理自己的业务。

在这里插入图片描述
接着线程B进入，也调用lock方法，进行状态比较的时候，发现线程A正在占用，所以就会走acquire(1);方法

    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

先调用tryAcquire(arg)，尝试再次获取锁

 /**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();   // 线程A已经占用，状态更改为1
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {  //  获取当前获取独占的的所有者的线程  线程A
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;  // 返回false
        }

接着进入addWaiter(Node.EXCLUSIVE)方法

 /**
     * Creates and enqueues node for current thread and given mode.
     *
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
     * @return the new node
     */
    private Node addWaiter(Node mode) {
    	 // 该node节点是封装线程B的节点
        Node node = new Node(Thread.currentThread(), mode);  // 自定义一个节点根据当前的线程以及占用模式    获取当前的线程，已经占用模式   独占 
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;  // 初始状态是null  将null赋值值新创建节点 
        if (pred != null) {
            node.prev = pred; //
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);  // 将节点插入队列中
        return node;  // 返回线程B的节点
    }

线程B将创建的节点插入队列

 /**
     * Inserts node into queue, initializing if necessary. See picture above.
     * @param node the node to insert
     * @return node's predecessor
     */
    private Node enq(final Node node) { // 该node节点是封装线程B的节点
        for (;;) { // 自旋  通过自旋 进入下一轮判断 
            Node t = tail;  // 此时tail为null 
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))  // 插入一个哨兵节点
                    tail = head; // 此时head为传过来的node哨兵节点  赋值给尾节点
            } else {  // 第二次进来 t的值为哨兵节点
                node.prev = t;  //线程B的前置节点是哨兵节点
                if (compareAndSetTail(t, node)) {  
                // t是哨兵节点  node是线程B封装的节点    期望是哨兵节点 实际也是哨兵节点  尾节点更改为 线程B封装的节点												                  	
                    t.next = node;  // 设置哨兵的后置节点是 线程B封装的节点	
                    return t; // 返回哨兵节点
                }
            }
        }
    }

    /**
     * CAS head field. Used only by enq.
     */
    private final boolean compareAndSetHead(Node update) {
        return unsafe.compareAndSwapObject(this, headOffset, null, update); // 将输入的节点和预期的节点进行比较 如果原来的为null 则设置为传过来的节点
    }
  /**
     * CAS tail field. Used only by enq.
     */
    private final boolean compareAndSetTail(Node expect, Node update) {  // 比较期望的节点和实际的节点是否相同，相同则更新值
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }

然后线程B进入acquireQueued(addWaiter(Node.EXCLUSIVE), arg))方法，

/**
     * Acquires in exclusive uninterruptible mode for thread already in
     * queue. Used by condition wait methods as well as acquire.
     *
     * @param node the node
     * @param arg the acquire argument
     * @return {@code true} if interrupted while waiting
     */
    final boolean acquireQueued(final Node node, int arg) {   // 该节点是线程B的节点
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor(); // 获取线程B节点的前置节点
                if (p == head && tryAcquire(arg)) { // 判断是否是头节点并尝试获取锁   
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                // 线程B返回flase 再次此自旋
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

 /**
         * Returns previous node, or throws NullPointerException if null.
         * Use when predecessor cannot be null.  The null check could
         * be elided, but is present to help the VM.
         *
         * @return the predecessor of this node
         */
        final Node predecessor() throws NullPointerException {
            Node p = prev; // 获取哨兵节点
            if (p == null)
                throw new NullPointerException();
            else
                return p; // 返回
        }


/**
     * Checks and updates status for a node that failed to acquire.
     * Returns true if thread should block. This is the main signal
     * control in all acquire loops.  Requires that pred == node.prev.
     *
     * @param pred node's predecessor holding status
     * @param node the node
     * @return {@code true} if thread should block
     */
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { // pred  哨兵节点 node 线程B节点
        int ws = pred.waitStatus; // 获取节点的状态值
        if (ws == Node.SIGNAL) 
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);  // CAS比较
        }
        return false; 
    }

 /**
     * CAS waitStatus field of a node.
     */
    private static final boolean compareAndSetWaitStatus(Node node,
                                                         int expect,
                                                         int update) {
        return unsafe.compareAndSwapInt(node, waitStatusOffset,
                                        expect, update);
    }

 /**
     * Convenience method to park and then check if interrupted
     *
     * @return {@code true} if interrupted
     */
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);  // 消耗许可证，未获取进入阻塞状态
        return Thread.interrupted();
    }

在这里插入图片描述

线程B加入等待队列。
在这里插入图片描述

线程A依然工作，线程C如线程B那样炮制加入等待队列。
双向链表中，第一个节点为虚节点(也叫哨兵节点)，其实并不存储任何信息，只是占位。真正的第一个有数据的节点，是从第二个节点开始的。

假设线程A工作结束，调用unLock()，释放锁占用。
在这里插入图片描述

线程A调用unlock()方法

    public void unlock() {
        sync.release(1);
    }
 /**
     * Releases in exclusive mode.  Implemented by unblocking one or
     * more threads if {@link #tryRelease} returns true.
     * This method can be used to implement method {@link Lock#unlock}.
     *
     * @param arg the release argument.  This value is conveyed to
     *        {@link #tryRelease} but is otherwise uninterpreted and
     *        can represent anything you like.
     * @return the value returned from {@link #tryRelease}
     */
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;  // 获取到线程B
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);   // 锁的状态更改为原始的  释放独占所有者的线程
            return free;
        }

 /**
     * Wakes up node's successor, if one exists.
     *
     * @param node the node
     */
    private void 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.
         */
        Node s = node.next;  // 获取线程B的下个节点
        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); // 生产 许可证 
    }
    
 /**
     * CAS waitStatus field of a node.
     */
    private static final boolean compareAndSetWaitStatus(Node node,
                                                         int expect,
                                                         int update) {
        return unsafe.compareAndSwapInt(node, waitStatusOffset,
                                        expect, update);
    }

获取到许可证 线程B不在阻塞，再次去尝试获取锁成功，线程B执行业务。线程C也是如此。

后端技术那点事
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AQS源码分析
pony的博客
03-21 651
本文对Java中多线程的底层基础框架AQS做了比较深入的原理分析和源码阅读，特别是针对如何保持自旋做了着重解读
JUC(一)-AQS源码分析
01-21
AQS源码分析一、锁的介绍1.1 乐观锁/悲观锁1.2 共享锁/独占锁1.3 公平锁/非公平锁1.4 小结二、AQS框架结构介绍2.1 类图2.2 AQS数据结构三、源码详解3.1 acquire源码详解3.2 release源码详解四、从ReentranLock看公平...
JDK源码——AQS源码
庄小焱
11-24 936
AQS 就是一个抽象类，继承了AbstractOwnableSynchronizer ，主要用来构建锁和同步器。这个类在 java.util.concurrent.locks 包下面，AQS为构建锁和同步器提供了一些通用功能的实现，因此，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如 ReentrantLock，Semaphore，其他的 ReentrantReadWriteLock，SynchronousQueue，FutureTask(jdk1.7) 等等皆是基于 AQS 的。
图文并茂，带你深入了解AQS的源码
wr_java的博客
04-11 175
如果你想深入研究Java并发的话，那么AQS一定是绕不开的一块知识点，Java并发包很多的同步工具类底层都是基于AQS来实现的，比如我们工作中经常用的Lock工具ReentrantLock、栅栏CountDownLatch、信号量Semaphore等，而且关于AQS的知识点也是面试中经常考察的内容，所以，无论是为了更好的使用还是为了应付面试，深入学习AQS都很有必要。CAS。
并发编程-AQS介绍(结合源码说明)
最新发布
qq_25409421的博客
03-11 1081
AQS全称为AbstractQueuedSynchronizer，它提供了一个FIFO（First in First out 先入先出）队列，可以看成是一个用来实现同步锁以及其他涉及到同步功能的核心组件，常见的有:ReentrantLock、CountDownLatch等。想要学习并发编程，就不得不学习AQS,我们一起来看看这个神奇的队列吧，看他是如何实现的锁。
源码详解CountDownLatch
12-21
AQS 是一个抽象类，提供了一套基于共享模式的同步框架，许多并发工具如 ReentrantLock、Semaphore 和 CyclicBarrier 都基于 AQS 实现。 CountDownLatch 的典型应用场景是在主程序中创建一个 CountDownLatch 对象，...
ReentrantLock源码详解--条件锁
08-25
ReentrantLock源码详解--条件锁 ReentrantLock源码详解中最重要的一个部分就是条件锁，条件锁是指在获取锁之后发现当前业务场景自己无法处理，而需要等待某个条件的出现才可以继续处理时使用的一种锁。今天我们来...
Java AQS详解.docx
06-21
**四、源码详解** AQS 的核心方法包括 `acquire()` 和 `release()`，分别对应获取和释放资源。`acquire()` 方法会尝试直接获取资源，失败则将线程加入等待队列。`release()` 方法负责释放资源，并可能唤醒等待队列...
ReentrantLock源码详解--公平锁、非公平锁
08-25
ReentrantLock源码详解--公平锁、非公平锁 ReentrantLock是一种重入锁，实现了Lock接口，能够对共享资源重复加锁，即当前线程获取该锁再次获取不会被阻塞。ReentrantLock的可重入性是通过继承AQS...
Java并发编程系列-AQS源码解析
08-13
1.ReentrantLock源码解析 2.AQS队列 源码解析 3.lock上锁过程源码分析
AQS源码剖析，完整流程解读
朱大虾
09-09 186
AQS是什么？AQS即AbstractQueuedSynchronizer缩写，翻译为抽象队列同步器，是一种用来构建锁和同步器的框架。 平时使用较多的ReentrantLock、CountDownLatch就是基于AQS实现。 AQS基于CLH队列分配的模式有两种：默认*独占*模式和*共享*模式 AQS完整流程解读，获取锁、释放锁、await等待、signal，同步队列和等待队列的转换
Signal ()函数详细介绍 Linux函数
热门推荐
顾修忠的博客
04-18 14万+
signal()函数理解 在 这个头文件中。 signal（参数1，参数2）； 参数1：我们要进行处理的信号。系统的信号我们可以再终端键入 kill -l查看(共64个)。其实这些信号时系统定义的宏。 参数2：我们处理的方式（是系统默认还是忽略还是捕获）。 一般有3中方式进行操作。 （1）eg: signal(SIGINT ,SIG_ING ); //SIG_ING 代表忽略SIGI
AQS源码分析(含图解详细流程)
阿顾的博客
06-09 9103
本文围绕reentrantLock源码分析来了解AQS 文章目录一 AQS是什么二 ReentrantLock重入锁 一 AQS是什么 二 ReentrantLock重入锁 ​重入锁的意思就是，线程thread1执行ReentrantLock的lock()方法获取到锁之后且没有释放锁，再次调用lock()方法的时候，不会阻塞，直接增加重入次数，具体的在哪里增加次数，后面源码分析会体现，我们看下下面...
AQS源码解读
weixin_39312465的博客
11-05 5347
参考自：http://www.cnblogs.com/waterystone/p/4920797.html， https://blog.csdn.net/qq_30572275/article/details/80297047 AQS全名AbstractQueuedSynchronizer，就和字面上一样，是维护了一个队列的同步器框架。 AQS类里有一个Node类，对线程进行了封装。看看里面的字...
AQS源码解析
weixin_45906061的博客
06-16 325
AQS是抽象的队列式的同步器，内部定义了很多锁相关的方法，我们熟知的、、、等都是基于来实现的。AQS的核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。中 维护了一个（代表共享资源）和一个线程等待队列（CLH的变种，双向链表，多线程争用资源被阻塞时会进入此队列）。这里能够保证多线程下的可见..
JAVA AQS抽象队列同步器详解
Heqianqian的博客
09-21 1906
之前看到一篇很好的介绍AQS抽象队列同步器的文章，分享下。框架维护了一个state（代表共享资源，注意是volatile修饰的保证可见性）和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）state的访问方式有三种： getState() setState() compareAndSetState() AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如Reen
AQS源码详解
KLordy的博客
03-07 324
一、AQS架构介绍 前一批文章介绍了JUC中为了减少锁竞争而用的CAS和Unsafe类，那么针对JUC中的各种同步器，例如常用的ReentrantLock、CountDownLatch等，他们的实现都是继承自AbstractQueuedSynchronizer这个抽象类的，和CAS以及Unsafe一样，这个类是JUC中非常基础的一个类，为了在后续更好的理解各种依托它而实现的类的原理，我们很有必要先...
Java AQS 详解
04-26
AQS (AbstractQueuedSynchronizer) 类是 java.util.concurrent 包中提供的锁的基础框架，它是实现锁和其他同步工具的基础；同时，它也是 ReentrantLock、Semaphore、CountDownLatch 等高级同步工具的底层实现。AQS ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值