同步工具-Synchronizer(2) 独占模式

Synchronizer
．
　　铺垫了这么多，终于到了我们的Synchronizer了。其实jdk的很多阻塞工具都是基于一个通用的类构建的例如ReentrantLock,FutureTask,Semaphore,CountDownLatch等等，这个就是AbstractQueuedSynchronizer。AQS也是面试当中很容易问到的一环。
　　ReentrantLock,FutureTask,Semaphore,CountDownLatch这些类都需要的是通过自身的状态来判断是否阻塞当前线程，或者是唤醒被阻塞的线程。
　　1.ReentrantLock#lock(),如果当前的锁未被其他线程占有，或者是点用着本身已经占有了锁那么lock方法直接返回，否则阻塞。ReentrantLock#Unlock()则是根据当前线程是否已经不占有锁来释放那些阻塞在Lock方法里的线程。
　　2.CountDownLatch#await()，则是根据自身的一个次数是否是0来决定是否阻塞当前线程，而他的CountDownLatch#countDown()，则是根据自身次数是否是0来决定是否唤醒阻塞的线程。
　　所以AQS提供了一个int值state来表示状态的抽象，并提供getState，setState，compareAndSetState等方法供子类自己去控制或是判断自身状态，提供tryAcquire（独占），tryAcquireShare（共享） 利用返回值决定是否阻塞调用线程，提供与之对应的tryRelease，tryReleaseShare 利用返回值决定是否唤醒被阻塞的线程。
　　下面我们先介绍一个独占模式AQS用法。

public class SimpleLatch {
	private Sync sync = new Sync();

	public void pass() {
		sync.acquire(1);
	};

	public void open() {
		sync.release(1);
	};

	private static class Sync extends AbstractQueuedSynchronizer {
		/**
		 * 
		 */
		private static final long serialVersionUID = 1L;

		@Override
		protected boolean tryAcquire(int arg) {
			// state 0表示关闭 1表示打开 默认关闭
			return getState() == 1;
		}

		@Override
		protected boolean tryRelease(int arg) {
			setState(1);
			return true;
		}
	}
}

测试代码

	public void testSimple() {
		SimpleLatch simpleLatch = new SimpleLatch();
		for (int i = 0; i < 1; i++) {
			new Thread(() -> {
				simpleLatch.pass();
				System.out.println(Thread.currentThread().getName() + " Im passed!");
			}).start();
		}

		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("begin to open");
		simpleLatch.open();
	}

结果
begin to open
Thread-0 Im passed!

SimpleLatch 是一个简单的二元闭锁。只有当状态为1时才允许线程通过，使用的是AQS提供的独占模式锁。
　　下面看看AQS的源码他是怎么实现的。
AQS独占模式
1.获取

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

首先判断是否能够获取状态，可以的话直接返回。

    private Node addWaiter(Node mode) {
    	//实例化node对象，设置当前线程和独占模式。
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        //尾节点不为空时 自旋添加到同步链表，并设置尾节点，然后返回
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //尾节点为空
        enq(node);
        return node;
    }
    //尾节点为空 自旋把头，尾节点指向一个新实例化的节点，自旋向后面添加入参节点
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

获取失败时加入同步队列，如果同步队列没有实例化时实例化同步队列。之后加入同步队列，node中包含当前线程，waitState=0。（其中多次使用CAS自旋保证操作一定成功）。

    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;
                }
                //判断当前线程是否需要休息
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    	//获取前驱节点状态
        int ws = pred.waitStatus;
        //如果前驱节点等待被唤醒 则返回true，外层方法阻塞当前线程
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        //前驱节点为cancel 那么循环删除前面所有的cancel节点。
        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 {
        	// 0 或者 PROPAGATE，0则是当前节点还没来的及设置前驱节点状态，
        	// PROPAGATE则是共享模式中可能出现的情况
        	// 本线程设置前驱节点状态为SIGNAL。
            /*
             * 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);
        }
        //返回false 要求再次自旋。
        return false;
    }

    private final boolean parkAndCheckInterrupt() {
    	//阻塞当前线程
        LockSupport.park(this);
        //线程已被唤醒，检查是否被中断，此方法会清除中断标志位，所以在acquire方法中进行selfInterrupt()来补偿。
        return Thread.interrupted();
    }

2.释放

    public final boolean release(int arg) {
    	//如果释放成功
        if (tryRelease(arg)) {
        	//获取头结点
            Node h = head;
            //头结点部位空，并且状态不等0时(也就是状态==-1)
            if (h != null && h.waitStatus != 0)
				//注意此时头结点的后继节点已经设置前驱节点为SINGAL，
				//也就是说后继节点的线程可能已经阻塞,所以需要唤醒后继节点
                unparkSuccessor(h);
            //waitStatus ==0 也就是说后继节点还活着 还有一次tryAcquire的机会，所以不需要唤醒。
            return true;
        }
        return false;
    }

    private void unparkSuccessor(Node node) {
    	//设置入参节点的状态为0，可能会与后继节点的修改前驱节点操作产生并发，不过没关系。
    	//这里设置失败也没所谓
        /*
         * 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;
        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);
    }

．
　　所以说独占模式的话，一个线程调用release只会释放同步队列中第一个等待的线程，所以在SimpleLock的实现中，加入有多个线程调用pass，但是只有一个线程调用了open()的话，那么只有第一个线程会被释放，别的线程就尴尬了。
　　好了，下一篇我们就再去描述下一非独占模式的AQS实现，也就是一个release可以释放多个阻塞的线程。