ReentrantLock底层流程剖析---NonfairSync()

ReentrantLock实现公平和非公平锁
是靠内部类sync实现的
而sync是继承于AQS(AbstractQueuedSynchronizer类)

	//默认ReentrantLock是NonfairSync非公平锁
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

当我们调用reentrantlock的lock方法时

//ReentrantLock默认调用的是内部类sync的lock方法  默认也就是NonfairSync的lock方法
 public void lock() {
        sync.lock();
    }
static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
//AQS类
 protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }
unsafe.compareAndSwapInt(this, stateOffset, expect, update);
//第一个参数是NonfairSync对象
//第二个参数是NonfairSync对象内存地址
//第三个参数是期望内存值
//第四个参数是修改值

看源码我们可以发现 NonfairSync重写了lock和tryAcquire方法
当我们调用reentrantlock的lock方法时 调用的是
NonfairSync的lock方法 此时先进行CAS(compareAndSetState)判断
调用父级AQS类的compareAndSetState 接着调用unsafe类的compareAndSwapInt方法

final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

修改成功的话就执行setExclusiveOwnerThread(Thread.currentThread());把当前线程设值到属性exclusiveOwnerThread(AQS的父级AOS类的属性 继承获得)
否则调用(AQS 的acquire方法)

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

因为NonfairSync重写了tryAcquire方法 所以调用NonfairSync的tryAcquire方法

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

调用sync内部类的nonfairTryAcquire(acquires)方法

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                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;
            }
            return false;
        }

因为第一次compareAndSetState 没有成功
进入到nonfairTryAcquire方法
先判断state==0 state是AQS的成员变量

    private volatile int state;

如果state为0 说明没有人得到锁(也就是修改compareAndSetState不成功)调用setExclusiveOwnerThread 设置线程为当前线程并返回
调用业务代码

否则有人得到锁 判断该线程是不是当前线程
如果是当前线程 state+=acquires 否则就返回false
继续调用acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
//EXCLUSIVE默认值为null 
private Node addWaiter(Node mode) {
		//传入的mode参数为null 以当前线程构建node节点
        Node node = new Node(Thread.currentThread(), mode);
        
        Node pred = tail;
        //尾节点不为空 设置前置节点为尾节点
        if (pred != null) {
            node.prev = pred;
            //多线程同时抢尾节点 就通过compareAndSetTail调用
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

构造Node节点通过AQS里面的Node类

Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }
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

继续执行acquireQueued方法传入当前线程节点和参数

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            //注意,它是死循环
            for (;;) {
            	//p为前节点
                final Node p = node.predecessor();
                //如果前节点已经是haed节点了,此时可以尝试获取下锁,
            //如果获取锁成功了,就将自己设置为head节点并且回收原head节点。
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //设置前节点的状态为 SIGNAL,并且挂起当前线程
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
        //如果某种情况下,跳出了死循环,并且failed值为true,则需要删除当前节点,取消等待涣
            if (failed)
                cancelAcquire(node);
        }
    }
    final boolean acquireQueued(final Node node, int arg) {
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } catch (RuntimeException ex) {
            cancelAcquire(node);
            throw ex;
        }
    }

仔细看看这个方法是个无限循环,感觉如果p == head && tryAcquire(arg)条件不满足循环将永远无法结束,当然不会出现死循环,奥秘在于第12行的parkAndCheckInterrupt会把当前线程挂起,从而阻塞住线程的调用栈。

shouldParkAfterFailedAcquire中:

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park
             */
            return true;
        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 {
            /*
             * 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;
    }

检查原则在于:

  • 规则1:如果前继的节点状态为SIGNAL,表明当前节点需要unpark,则返回成功,此时acquireQueued方法的第12行(parkAndCheckInterrupt)将导致线程阻塞
  • 规则2:如果前继节点状态为CANCELLED(ws>0),说明前置节点已经被放弃,则回溯到一个非取消的前继节点,返回false,acquireQueued方法的无限循环将递归调用该方法,直至规则1返回true,导致线程阻塞
  • 规则3:如果前继节点状态为非SIGNAL、非CANCELLED,则设置前继的状态为SIGNAL,返回false后进入acquireQueued的无限循环,与规则2同
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

如前面所述,LockSupport.park最终把线程交给系统(Linux)内核进行阻塞。当然也不是马上把请求不到锁的线程进行阻塞,还要检查该线程的状态,比如如果该线程处于Cancel状态则没有必要

总体看来,shouldParkAfterFailedAcquire就是靠前继节点判断当前线程是否应该被阻塞,如果前继节点处于CANCELLED状态,则顺便删除这些节点重新构造队列。

至此,锁住线程的逻辑已经完成,下面讨论解锁的过程。

解锁

请求锁不成功的线程会被挂起在acquireQueued方法的for循环第二个if判断,以后的代码必须等线程被解锁锁才能执行,假如被阻塞的线程得到解锁,则执行interrupted = true;,即设置interrupted = true,之后又进入无限循环。不停tryAcquire直至成功

从无限循环的代码可以看出,并不是得到解锁的线程一定能获得锁,必须调用tryAccquire重新竞争,因为锁是非公平的,有可能被新加入的线程获得,从而导致刚被唤醒的线程再次被阻塞,这个细节充分体现了“非公平”的精髓。通过之后将要介绍的解锁机制会看到,第一个被解锁的线程就是Head,因此p == head的判断基本都会成功。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值