Java多线程之AQS(AbstractQueuedSynchronizer )实现原理和源码分析(三)

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/u014730165/article/details/83791491

章节概览、


1、回顾

上一章节,我们分析了ReentrantLock的源码:


2、AQS 队列同步器概述

本章节我们深入分析下AQS(AbstractQueuedSynchronizer)队列同步器源码,AQS是用来构建锁或者其他同步组件的基础框架。其主要运用的核心技术点有三个:

  1. CAS 原子语义,乐观锁
  2. 维护一个int成员变量表示同步状态。保证该成员变量的可见性
  3. 维护一个同步队列CLH(FIFO)队列。内部实现是一个双向链表
2.1、AQS队列同步器类结构图

在这里插入图片描述
从类结构图中可以看出AbstractQueuedSynchronizer类继承AbstractOwnableSynchronizer。其有2个内部类,分别为Node和ConditionObject。其中ConditionObject会在后面的章节中进行详细分析。其实现类有Sync。Sync在上一章节中进行了详细的分析。

2.2、AbstractOwnableSynchronizer 抽象类源码分析

AbstractOwnableSynchronizer 主要用来设置独占锁拥有者的线程

public abstract class AbstractOwnableSynchronizer
    implements java.io.Serializable {
    /**
     * 被保护的构造函数
     */
    protected AbstractOwnableSynchronizer() { }

    // 独占模式拥有锁的线程
    private transient Thread exclusiveOwnerThread;
    
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}
2.3、内部类Node源码分析

Node是队列同步器中组成元素。其维护着当前指向的线程,上一个节点的引用,以及下一个节点的引用。

static final class Node {
        //标记表示节点正在共享模式中等待
        static final Node SHARED = new Node();
        //标记表示节点正在独占模式下等待
        static final Node EXCLUSIVE = null;
        //waitStatus值表示线程已取消
        static final int CANCELLED =  1;
        //waitStatus值表示后继者的线程需要被唤醒
        static final int SIGNAL    = -1;
        //waitStatus值表示线程正在等待条件
        static final int CONDITION = -2;
        //waitStatus值表示下一个acquireShared应无条件传播
        static final int PROPAGATE = -3;
        
        volatile int waitStatus;
       // 当前节点的前驱节点
        volatile Node prev;
	   // 当前节点的后续节点
        volatile Node next;
      // 当前节点指向的线程
        volatile Thread thread;

      // nextWaiter是“区别当前CLH队列是 ‘独占锁’队列 还是 ‘共享锁’队列 的标记”
     // 若nextWaiter=SHARED,则CLH队列是“共享锁”队列;
     // 若nextWaiter=EXCLUSIVE,(即nextWaiter=null),则CLH队列是“独占锁”队列。
        Node nextWaiter;

        /**
         * Returns true if node is waiting in shared mode.
         */
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        /**
         * 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;
        }

        Node() {    // Used to establish initial head or SHARED marker
        }

  		// Used by addWaiter
        Node(Thread thread, Node mode) {   
            this.nextWaiter = mode;
            this.thread = thread;
        }
		 // Used by Condition
        Node(Thread thread, int waitStatus) {
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }
2.4、 AbstractQueuedSynchronizer类的构造函数和成员变量
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
	    implements java.io.Serializable {
		// 受保护的构造函数
		protected AbstractQueuedSynchronizer() { }
		// CLH队列的head节点,除了初始化,仅通过setHead()方法进行修改
		private transient volatile Node head;
		// CLH队列的tail节点,修改仅通过方法enq添加新的等待节点
		private transient volatile Node tail;
		// 同步状态
		private volatile int state;
 }

AbstractOwnableSynchronizer 内部维护一个同步队列,主要通过双向链表进行维护。没有获得锁的线程,将会被添加到同步队列中。当释放锁的时候,会唤醒队列中的一个节点。
在这里插入图片描述
同步队列主要通过成员变量head,tail进行维护。


3、ReentrantLock模拟窗口售票demo

public class ReentrantLockDemo01 implements Runnable {

    private Lock lock = new ReentrantLock();

    private int tickets = 200;

    @Override
    public void run() {
        while (true) {
            lock.lock(); // 获取锁
            try {
                if (tickets > 0) {
                    TimeUnit.MILLISECONDS.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " " + tickets--);
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock(); // 释放所
            }
        }
    }

    public static void main(String[] args) {
        ReentrantLockDemo01 reentrantLockDemo = new ReentrantLockDemo01();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(reentrantLockDemo, "thread" + i);
            thread.start();
        }
    }
}

模拟售票的多线程demo。其中主要使用到了lock()获取锁,unlock()释放锁这两个核心方法。我们源码分析从这两个方法分别为出入口进行深入分析。


4、AbstractQueuedSynchronizer 源码分析

4.1、初始化ReentrantLock

Lock lock = new ReentrantLock();

构造函数:

  public ReentrantLock() {
  	// 通过构造函数,构造非公平获得锁,即抢占式获取
        sync = new NonfairSync();
    }
4.2、 调用lock方法
4.2.1、 调用ReentrantLock的lock方法,其内部是现实调用NonfairSync的lock方法
//ReentrantLock的lock方法
public void lock() {
        sync.lock();
    }
4.2.2、 NonfairSync的lock方法
final void lock() {
  // 通过compareAndSetState方法,进行cas判断,获取当前锁
   if (compareAndSetState(0, 1))
   		// 获取锁成功,设置当前线程为锁拥有线程
         setExclusiveOwnerThread(Thread.currentThread());
     else
     	// 获取锁失败,调用acquire方法
         acquire(1);
 }

调用 acquire(1),传入参数为1。其中1的作用是用于可重入锁的状态标识。如果当前线程已经拥有锁,直接将当前系统的 state + 1,用于判断当前锁所拥有的句柄数。

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

acquire方法分为2大步骤:tryAcquire(arg) 和 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

4.2.3、 tryAcquire(int arg)

调用NonfairSync的tryAcquire方法,尝试去获取锁

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

调用Sync的nonfairTryAcquire(acquires)非公平尝试获取锁。

final boolean nonfairTryAcquire(int acquires) {
// 获取当前线程
      final Thread current = Thread.currentThread();
  // 获取当前系统的同步状态变量state
      int c = getState();
  // 判断当前的系统状态变量是否为0
  // 其中0,表示当前锁空闲。大于0表示当前系统锁已经被占用
      if (c == 0) {
      // 利用CAS原语设置当前state的状态值为1,立刻返回
          if (compareAndSetState(0, acquires)) {
          // 如果设置成功,表示已经获取当前锁,设置当前锁的拥有者为当前线程
              setExclusiveOwnerThread(current);
           // 返回获取成功
              return true;
          }
      }
      // 如果当前是state不为0,判断当前线程是否已经拥有锁
      // 因为ReentrantLock是可冲入锁,所以如果当前线程已经拥有锁的情况下,可以再次使用该锁
      else if (current == getExclusiveOwnerThread()) {
      // 如果当前线程已经拥有锁,则把当前的 state + 1
          int nextc = c + acquires;
          if (nextc < 0) // overflow
              throw new Error("Maximum lock count exceeded");
      // 设置当前state的值
          setState(nextc);
          // 返回成功
          return true;
      }
      return false;
  }

首先当前线程会尝试的去获取锁。如果获取失败,判断当前线程是否已经拥有锁。如果已经拥有锁,根据可重入锁的特性,对state + 1操作。

4.2.4、acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

如果第一步已经成功,当前线程获得锁,直接运行结束。如果第一步tryAcquire(arg)获取锁失败。则来到第二个判断。 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)。第二步的判断又可以分为两小步骤进行。下面分别进行分析.

  • addWaiter(Node mode)

首先addWaiter的传入参数是Node.EXCLUSIVE,标记表示节点正在独占模式下等待。
addWaiter主要做的事情是,将原来的tail节点,设置为前驱节点,将tail的指针指向当前的node节点,其实就是将node节点追加到队列的尾部,把tail指针下移

private Node addWaiter(Node mode) {
		// 实例化当前的node节点。mode为独占模式下的标记,null
        Node node = new Node(Thread.currentThread(), mode);
        Node pred = tail;
        // 如果当前的tail不为空
        if (pred != null) {
        	// 如果pred不为空,说明当前tail已经存在
            node.prev = pred;
            // 通过cas快速替换当前tail节点为node节点
            if (compareAndSetTail(pred, node)) {
            // 将tail节点的next指向node节点,返回node
                pred.next = node;
                return node;
            }
        }
        如果设置失败的话,调用enq方法
        enq(node);
        return node;
    }

enq(node)方法利用自旋锁的方法,不断的尝试尾部添加,直到添加成功为止

 private Node enq(final Node node) {
 // 自旋锁,一直尝试添加,直到成功为止
        for (;;) {
            Node t = tail;
          // 如果tail为空,说明当前队列没有节点加入。  
            if (t == null) { // Must initialize
            // 如果tail == null,分别初始化tail和head,第一次初始化,tail == head
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
            //设置当前节点的前驱节点为 tail
                node.prev = t;
             设置当前的tail 为node节点
                if (compareAndSetTail(t, node)) {
               //通过上面的步骤,node节点已经执行了tail引用。而原来的tail引用变成了node节点的前驱节点
               // 设置tail节点的next为当前的node
                    t.next = node;
                    return t;
                }
            }
        }
    }

通过addWaiter方法,将当前的线程包装成node节点,添加到队列的尾部。

  • acquireQueued(final Node node, int arg)
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            // 死循环,直到满足条件退出
            // 首先将当前线程进行阻塞,等待其他线程进行唤醒
            // 其他线程进行唤醒以后,判断当前是否获取资源。此时,可能有其他线程的加入,导致获取失败
            for (;;) { 
            // 获取当前节点的前驱节点
                final Node p = node.predecessor();
            // 如果当前节点的前驱节点是head节点,且尝试获取锁成功
                if (p == head && tryAcquire(arg)) {
                // 设置当前的node节点为head节点
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                // 判断当前线程是否应该阻塞
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    // 如果当前线程被中断,则 parkAndCheckInterrupt()返回为true。interrupted = true
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
4.2.5、shouldParkAfterFailedAcquire(Node pred, Node node)

设置当前node节点的状态值:waitStatus

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        // 如果前驱节点为Node.SIGNAL,直接返回
        // Node.SIGNAL 表示后续节点需要唤醒
        if (ws == Node.SIGNAL)
            return true;
       // ws > 0 ,表示当前节点为CANCELLED节点
        if (ws > 0) {
           // 通过循环,找到 ws < 0 的节点,重新设置node节点的前驱节点
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
        // 设置当前pred的WaitStatus值为 Node.SIGNAL
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
4.2.6、parkAndCheckInterrupt()
private final boolean parkAndCheckInterrupt() {
	 // 将当前线程进行阻塞挂起,等待其他线程唤醒
        LockSupport.park(this);
    // 其他线程进行唤醒,返回为fase
        return Thread.interrupted();
    }

至此,lock()方法调用的分析已经全部完成。如果一个线程获取不到锁,将会被加入到同步器队列中。并且阻塞当前线程,等待其他线程进行唤醒操作。


4.3、 unlock() 源码分析

unlock()方法,主要用来释放当前所拥有的锁资源,同时唤醒下一个节点

4.3.1、unlock() 方法调用
// 调用sync的release方法。该方法的实现是在AbstractQueuedSynchronizer中
public void unlock() {
        sync.release(1);
    }
 
//AbstractQueuedSynchronizer中的release方法
public final boolean release(int arg) {
// 尝试去释放当前锁
     if (tryRelease(arg)) {
         Node h = head;
         // 如果 h != null 且 h.waitStatus!=0 的情况下唤醒下一个线程
         if (h != null && h.waitStatus != 0)
         	// 唤醒线程
             unparkSuccessor(h);
         return true;
     }
     return false;
 }
4.3.2、 tryRelease(int releases) 方法调用
// 当前方法的位置
// java.util.concurrent.locks.ReentrantLock.Sync#tryRelease
 protected final boolean tryRelease(int releases) {
 // 可重入锁,对当前的state -1
	 int c = getState() - releases;
		      if (Thread.currentThread() != getExclusiveOwnerThread())
		          throw new IllegalMonitorStateException();
		      boolean free = false;
		      if (c == 0) {
		          free = true;
		          // 将当前拥有锁的线程设置为空
		          setExclusiveOwnerThread(null);
		      }
		    // 设置 state的值
		      setState(c);
		      return free;
 }
4.3.3、 unparkSuccessor(Node node) 方法调用

当前方法传入的参数为head节点

private void unparkSuccessor(Node node) {
		// 获取当前node节点的waitStatus
	     int ws = node.waitStatus;
	    // 如果当前 ws < 0。通过 cas 设置当前的ws的值为0
	     if (ws < 0)
	         compareAndSetWaitStatus(node, ws, 0);
	     // 获取当前节点的后驱节点
	     Node s = node.next;
	     // 在waitStatus > 0 的情况下。说明当前的节点为CANCELLED
	     if (s == null || s.waitStatus > 0) {
	         s = null;
	         // 一直for循环,直到 t == null 或者 t == head 的情况下结束。
	         for (Node t = tail; t != null && t != node; t = t.prev)
	         // 找到节点满足 t.waitStatus <= 0 的节点,并且复制给s
	             if (t.waitStatus <= 0)
	                 s = t;
	     }
	     // 如果 s != null 的情况下,唤醒当前线程。去争取资源
	     if (s != null)
	         LockSupport.unpark(s.thread);
}

5、结语

至此,AQS关于lock(),unlock()方法的核心源码已经分析完成。通过源码分析,我们可以深入的理解其获取锁,释放锁的整个过程。后续将分析在Condition的情况下。其核心源码的实现情况。主要完成了以下几件事情:

  1. 调用自定义同步器的tryAcquire()尝试直接去获取资源,如果成功则直接返回;

  2. 如果尝试获取资源没有成功,将当前线程封装成Node节点,通过addWaiter()将该线程加入等待队列的尾部,并标记为独占模式;

  3. acquireQueued()使线程在等待队列中等待,首先尝试的去获取资源,如果获得到了资源,直接返回。如果没获取到资源,则将当前线程进行阻塞。等到其他线程执行完成对其进行唤醒。

  4. 如果线程在等待过程中被中断过,当前线程不会立即响应。等到当前线程再次获取执行权以后。进行自我中断。通过selfInterrupt()方法。

展开阅读全文

没有更多推荐了,返回首页