Java多线程之lock原理

一、AQS(AbstractQueuedSynchronizer)

Lock之所以能实现线程安全的锁，主要的核心是AQS，AQS提供了一个FIFO队列，可以看做是一个用来实现锁以及其他需要同步功能的框架。AQS的使用依靠继承来完成，子类通过继承自AQS并实现所需的方法来管理同步状态。例如常见的ReentrantLock，CountDownLatch等。

从使用上来说，AQS的功能可以分为两种：独占和共享。

独占锁模式下，每次只能有一个线程持有锁，ReentrantLock就是以独占方式实现的互斥锁。

共享锁模式下，允许多个线程同时获取锁，并发访问共享资源，比如ReentrantReadWriteLock。

AQS的内部实现

同步器依赖内部的同步队列（一个FIFO双向队列）来完成同步状态的管理，当前线程获取同步状态失败时，同步器会将当前线程以及等待状态等信息构造成为一个节点（Node）并将其加入同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点中的线程唤醒，使其再次尝试获取同步状态。

1、Node的主要属性：

static final class Node {
    //表示节点的状态，包含SIGNAL、CANCELLED、CONDITION、PROPAGATE、INITIAL
    volatile int waitStatus;
    //前继节点
    volatile Node prev;
    //后继节点
    volatile Node next;
    //当前线程
    volatile Thread thread;
    //存储在condition队列中的后继节点
    Node nextWaiter; 
}

2、waitStatus节点的几种状态：

CANCELLED，值为1，由于在同步队列中等待的线程等待超时或者被中断，需要从同步队列中取消等待，节点进入该状态将不会变化。

SIGNAL，值为-1，后继节点的线程处于等待状态，而当前节点的线程如果释放了同步状态或者被取消，将会通知后继节点，使后继节点得以运行。

CONDITION，值为-2，节点在等待队列中，节点线程等待在Condition上，当其他线程对Condition调用了signal()方法后，该节点将会从等待队列中转移到同步队列中，加入到对同步状态的获取中。

PROPAGATE，值为-3，表示下一次共享式同步状态获取将会无条件地被传播下去。

INITAL，值为0，初始状态。

3、设置尾节点：

当一个线程成功地获取了同步状态（或者锁），其他线程将无法获取，转而被构造成为节点并加入同步队列，而这个过程必须保证线程安全，因此同步器提供了一个基于CAS的设置尾节点的方法：compareAndSetTail(Node expect,Nodeupdate)，它需要传递当前线程“认为”的尾节点和当前节点，只有设置成功后，当前节点才正式与之前的尾节点建立关联。

    /**
     * CAS tail field. Used only by enq.
     */
    private final boolean compareAndSetTail(Node expect, Node update) {
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }

4、设置首节点：

同步队列遵循FIFO，首节点是获取同步状态成功的节点，首节点的线程在释放同步状态时，将会唤醒后继节点，而后继节点将会在获取同步状态成功时将自己设置为首节点。

设置首节点是通过获取同步状态成功的线程来完成的，由于只有一个线程能够成功获取到同步状态，因此设置头节点的方法并不需要使用CAS来保证，它只需要将首节点设置成为原首节点的后继节点并断开原首节点的next引用即可。

    /**
     * CAS head field. Used only by enq.
     */
    private final boolean compareAndSetHead(Node update) {
        return unsafe.compareAndSwapObject(this, headOffset, null, update);
    }

5、state

AbstractQueuedSynchronizer还有一个重要变量state，用于记录是否有线程获取锁，可重入锁还记录了获取多少次锁， 没有锁住时，state为0，有线程获取锁时为1，可重入锁，每重新获取一次锁，state就加1，释放一次就减1。

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

二、ReentrantLock的实现原理

1、lock

ReentrantLock - > lock()

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

这个是获取锁的入口。sync是一个实现了AQS的抽象类，这个类的主要作用是用来实现同步控制的，sync有两个实现，一个是NonfairSync(非公平锁)、另一个是FailSync(公平锁)。

ReentrantLock - > NonfairSync.lock

    final void lock() {
        /*
          通过cas算法去改变state的值
          state=0表示无锁状态，state>0表示有锁状态
          这是跟公平锁的主要区别,一上来就试探锁是否空闲,如果可以插队，则设置获得锁的线程为当前线程
        */
        if (compareAndSetState(0, 1)) 
            //exclusiveOwnerThread属性是AQS从父类AbstractOwnableSynchronizer中继承的属性，用来保存当前占用锁的线程
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1); //尝试去获取锁
    }

当锁被占用时，执行acquire(1)，以下都是对这个方法的详细分析

    /**
      * 尝试获取独占锁，获取成功则返回
      * 获取失败则继续自旋获取锁，并且判断中断标识，如果中断标识为true，则设置线程中断
      * addWaiter方法把当前线程封装成Node，并添加到队列的尾部
      */
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

AQS - > tryAcquire
该方法尝试获取锁，如果成功就返回，如果不成功，则把当前线程和等待状态信息构造成一个Node节点，并将节点放入同步队列的尾部。然后为同步队列中的当前节点循环等待获取锁，直到成功。

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

AQS - > nofairTryAcquire

    /**
     * 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();
        //获取当前的状态，默认情况下是0表示无锁状态
        int c = getState();
        if (c == 0) {
            //通过cas来改变state状态的值，如果更新成功，表示获取锁成功
            //这个操作外部方法lock()就做过一次，这里再做只是为了再尝试一次，尽量以最简单的方式获取锁。
            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;
        }
        //如果状态不为0，且当前线程不是owner，则返回false
        return false;
    }

AQS- >enq
enq就是通过自旋操作把当前节点加入到队列中。

    /**
     * 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) {
        //无限循环，为什么采用for(;;)，是因为它执行的指令少，不占用寄存器
        for (;;) {
            Node t = tail; //第一次循环时，head, tail都为null
            //如果tail为null则说明队列首次使用,需要进行初始化
            if (t == null) { // Must initialize
                //设置头节点,如果失败则存在竞争,留至下一轮循环           
                if (compareAndSetHead(new Node()))
                    //用CAS的方式创建一个空的Node作为头结点，因为此时队列中只一个头结点，所以tail也指向head
                    tail = head;
                    //第一次循环执行结束
            } else { 
                //进行第二次循环时，tail不为null，进入else区域。
                //将当前线程的Node结点的prev指向tail，然后使用CAS将tail指向Node
                //这部分代码和addWaiter代码一样，将当前节点添加到队列
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    //t此时指向tail,所以可以CAS成功，将tail重新指向Node。
                    //此时t为更新前的tail的值，即指向空的头结点，t.next=node，就将头结点的后续结点指向Node，返回头结点
                    t.next = node;
                    return t;
                }
            }
        }
    }

AQS- >acquireQueued
前面addWaiter返回了插入的节点，作为acquireQueued方法的入参，这个方法主要用于争抢锁。

    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                //获取prev节点,若为null即刻抛出NullPointException
                final Node p = node.predecessor();
                //如果前驱为head才有资格进行锁的抢夺
                if (p == head && tryAcquire(arg)) {
                    //获取锁成功后就不需要再进行同步操作了,获取锁成功的线程作为新的head节点
                    setHead(node);
                    //凡是head节点,head.thread与head.prev永远为null, 但是head.next不为null
                    p.next = null; // help GC
                    failed = false; //获取锁成功
                    return interrupted;
                }
                //如果获取锁失败，则根据节点的waitStatus决定是否需要挂起线程
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    //若前面为true,则执行挂起,待下次唤醒的时候检测中断的标志
                    interrupted = true;
            }
        } finally {
            if (failed)
                //如果抛出异常则取消锁的获取,进行出队(sync queue)操作
                cancelAcquire(node);
        }
    }

原来的head节点释放锁以后，会从队列中移除，原来head节点的next节点会成为head节点。

AQS- >shouldParkAfterFailedAcquire
从上面的分析可以看出，只有队列的第二个节点可以有机会争用锁，如果成功获取锁，则此节点晋升为头节点。对于第三个及以后的节点，if (p == head)条件不成立，首先进行shouldParkAfterFailedAcquire(p, node)操作。

shouldParkAfterFailedAcquire方法是判断一个争用锁的线程是否应该被阻塞。它首先判断一个节点的前置节点的状态是否为Node.SIGNAL，如果是，是说明此节点已经将状态设置-如果锁释放，则应当通知它，所以它可以安全的阻塞了，返回true。

   /**
     * 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) {
        int ws = pred.waitStatus; //前继节点的状态
        if (ws == Node.SIGNAL) //如果是SIGNAL状态，意味着当前线程需要被unpark唤醒
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        /*
         * 如果前节点的状态大于0，即为CANCELLED状态时，则会从前节点开始逐步循环找到一个没有    
         * 被CANCELLED节点设置为当前节点的前节点，返回false。在下次循环执行 
         * shouldParkAfterFailedAcquire时，返回true。
         * 这个操作实际是把队列中CANCELLED节点剔除掉。
         */
        if (ws > 0) {
            /*
             * 如果前继节点是“取消”状态，则设置 “当前节点”的 “当前前继节点” 为 “‘原前继节
             *  点'的前继节点”。
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else { //如果前继节点为“0”或者“共享锁”状态，则设置前继节点为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);
        }
        return false;
    }

AQS- >parkAndCheckInterrupt
如果shouldParkAfterFailedAcquire返回了true，acquireQueued会继续执行parkAndCheckInterrupt()方法，它是通过LockSupport.park(this)将当前线程挂起到WATING状态，它需要等待一个中断、unpark方法来唤醒它，通过这样一种FIFO的机制的等待，来实现了Lock的操作。

   /**
     * Convenience method to park and then check if interrupted
     *
     * @return {@code true} if interrupted
     */
    private final boolean parkAndCheckInterrupt() {
        //LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞
        LockSupport.park(this);
        return Thread.interrupted();
    }

2、unlock

ReentrantLock - > unlock()

   /**
     * Attempts to release this lock.
     *
     * <p>If the current thread is the holder of this lock then the hold
     * count is decremented.  If the hold count is now zero then the lock
     * is released.  If the current thread is not the holder of this
     * lock then {@link IllegalMonitorStateException} is thrown.
     *
     * @throws IllegalMonitorStateException if the current thread does not
     *         hold this lock
     */
    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;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

ReentrantLock - > Sync.tryRelease
这个动作可以认为就是一个设置锁状态的操作，而且是将状态减掉传入的参数值（参数是1），如果结果状态为0，就将排它锁的Owner设置为null，以使得其它的线程有机会进行执行。 在排它锁中，加锁的时候状态会增加1（当然可以自己修改这个值），在解锁的时候减掉1，同一个锁，在可以重入后，可能会被叠加为2、3、4这些值，只有unlock()的次数与lock()的次数对应才会将Owner线程设置为空，而且也只有这种情况下才会返回true。

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases; // 这里是将锁的数量减1
            if (Thread.currentThread() != getExclusiveOwnerThread())
                // 如果释放的线程和获取锁的线程不是同一个，抛出非法监视器状态异常
                throw new IllegalMonitorStateException();
            boolean free = false;
            // 由于重入的关系，不是每次释放锁c都等于0，
            // 直到最后一次释放锁时，才会把当前线程释放
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

lock与unlock过程总结

在获取同步状态时，同步器维护一个同步队列，获取状态失败的线程都会被加入到队列中并在队列中进行自旋；移出队列（或停止自旋）的条件是前驱节点为头节点且成功获取了同步状态。在释放同步状态时，同步器调用tryRelease(int arg)方法释放同步状态，然后唤醒头节点的后继节点。