03.并发多线程AQS

AQS是什么

  • 全称是AbstractQueuedSynchronizer,(抽象队列同步器)
  • 它的定位手机为java中几乎所有的锁和同步器提供一个基础框架
  • AQS是基于FIFO的队列(First-In,First-Out,先进先出)实现的,并且内部维护了一个状态变量state,通过原子(CAS)更新这个状态变量即可以实现加锁解锁的操作

AQS的实现原理

思想

如果被请求的共享资源空闲,则将当前请求资源的线程设置为有效工作线程,并且将共享资源设置为锁定状态,如果被请求的共享资源被占用,那么就需要一套线程阻塞等待以及被唤醒是锁分配的机制,这个机制AQS是用CLH队列锁实现的,将即将暂时获取不到锁的线程加入到队列中。

CLH队列

CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列(虚拟的双向队列即不存在队列实例,仅存在结点之间的关联关系)。AQS是将每条请求共享资源的线程封装成一个CLH队列的一个结点来实现锁的分配
image

核心源码的分析
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {

    private static final long serialVersionUID = 7373984972572414691L;


    /**
     * Creates a new {@code AbstractQueuedSynchronizer} instance
     * with initial synchronization state of zero.
     */
    protected AbstractQueuedSynchronizer() { }
    
     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;
        // 标识后面的共享锁需要无条件的传播(共享锁需要连续唤醒读的线程)
        static final int PROPAGATE = -3;
        
        // 当前节点保存的线程对应的等待状态
        volatile int waitStatus;
    
        // 前一个节点
        volatile Node prev;
        
        // 后一个节点
        volatile Node next;
    
        // 当前节点保存的线程
        volatile Thread thread;
    
        // 下一个等待在条件上的节点(Condition锁时使用)
        Node nextWaiter;
    
        // 是否是共享模式
        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
            // 把共享模式还是互斥模式存储到nextWaiter这个字段里面了
            this.nextWaiter = mode;
            this.thread = thread;
        }
    
        // 节点的构造方法
        Node(Thread thread, int waitStatus) { // Used by Condition
            // 等待的状态,在Condition中使用
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

}   
    
AQS底层使用了模板方法模式

同步器的设计是基于模板方法模式的,如果需要自定义同步器一般的方式是这样的

  • 使用者继承AbstractQueuedSynchronizer并重写指定的方法(这些重写方法很简单,无非是对于贡献资源state的获取和释放)
  • 将AQS组合在自定义同步组件的实现中,并调用其模板方法,而这些模板方法会调用使用者重写的方法
自定义AQS的时候需要重写一下的几个方法
  1. isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
  2. tryAcquire(int)//独占方式。尝试获取资源,成功则返回true,失败则返回false。
  3. tryRelease(int)//独占方式。尝试释放资源,成功则返回true,失败则返回false。
  4. tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败;0表示成功,但没有剩余可用资源;正数表示成功,且有剩余资源。
  5. tryReleaseShared(int)//共享方式。尝试释放资源,成功则返回true,失败则返回false。
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页