ReetrantLock

总结一下ReetrantLock

ReetrantLock分为公平锁,以及非公平锁,默认情况下是非公平锁,分别总结一下这两种使用的异同点。

ReentrantLock 的成员变量有

private final Sync sync;
//这个就是AQS
abstract static class Sync extends AbstractQueuedSynchronizer 

首先使用ReetrantLock的时候,会先new一个出来这时候,默认的构造函数是构造一个非公平锁

public ReentrantLock() {
        sync = new NonfairSync();
    }

然后尝试调用加锁的时候,其实调用的是sync的lock方法

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

然后就会调用非公平锁的lock方法

final void lock() {
            //首先进行cas操作,把state的状态从0变成1,非公平锁和公平锁的区别就是,首先会进行一次CAS操作,如果线程拿到了锁,那就抢占了资源,这样的话,可能新的线程会优先于已经在队列里的那些线程拿到锁,这样不是按顺序的,就是非公平的了
            if (compareAndSetState(0, 1))
                //如果cas成功了,aqs的持有线程就是当前的线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //没有拿到锁,那就调用的AQS中的acquire
                acquire(1);
        }

如果当前线程没有拿到锁,那么就去执行acquire(1)方法

/**
     * 这里有几个步骤
     * 1.先尝试获取一下tryAcquire,
     * 2.如果获取不到锁,那就将当前线程添加到节点中addWaiter(Node.EXCLUSIVE) 添加到了CLH中
     * 3.acquireQueued通过自旋的方式不断的获取锁
     * 4.最终拿到了之后会中断自己
     * @param arg
     */
    public final void acquire(int arg) {
        //如果没有获取成功,那么就要添加到队列中了
        //再尝试获取一下,如果获取不到,就先加入
        if (!tryAcquire(arg) &&
                //独占模式,添加了一个,然后返回当前节点
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)){
            //当前线程自我中断
            selfInterrupt();
        }
    }

tryAcquire方法最后会调用ReetrantLock的Sync的nonfairTryAcquire方法

final boolean nonfairTryAcquire(int acquires) {
            //获取当前线程
            final Thread current = Thread.currentThread();
            //拿到当前锁的state
            int c = getState();
            //如果是0的话,就把aqs的state设置为acquires,当前就可以拿到锁了
            if (c == 0) {
                //尝试一下cas,如果成功就可以拿到锁了
                if (compareAndSetState(0, acquires)) {
                    //设置当前线程为当前lock所拥有的锁
                    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;
        }

其中addWaiter方法

/**
     * Creates and enqueues node for current thread and given mode.
     * 就是当前线程没有拿到锁的时候
     * 1.如果尾部节点有值,那么加到最后一个返回
     * 2.如果尾部节点没有值,添加一个节点,然后返回
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
     * @return the new node
     */
    private Node addWaiter(Node mode) {
        /**
         * 当前线程构建一个node,是独占模式的
         * new 出来的这个节点的结构是
         * node(当前线程,nextWaiter是个mode)
         */
        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;
            //将当前节点设置为尾部节点,使用cas设置一下
            if (compareAndSetTail(pred, node)) {
                //现在的尾部借点就是 node了,然后再将pred的next指向尾部,然后返回
                pred.next = node;
                return node;
            }
        }
        //如果尾部节点是空的,就建立一节点,头和尾都指向这个节点,而且自己指向自己[自己的pre指向自己,自己的next指向自己]
        enq(node);
        return node;
    }

private Node enq(final Node node) {
        //自旋操作
        for (;;) {
            //线程A:第一次的时候 tail是null,需要初始化
            //线程A:第二次进来的时候,由于是自旋 此时t=head=tail
            Node t = tail;
            if (t == null) { // Must initialize 必须进行初始化
                //尾巴节点是空的,先初始化一下head节点,再将head节点给tail节点
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                //线程A:第二次进来的时候,由于是自旋,
                //当前节点的前驱是t,有可能自己指向了自己
                node.prev = t;
                //这一步相当于把tail的引用指向了新增的node
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

执行如图


image.png

最后重点的自旋获取锁的方法acquireQueued

你可能感兴趣的:(ReetrantLock)