简单看看ReentrantLock(2)

当前位置:

首页 > Python基础教程 >

简单看看ReentrantLock(2)

Thread.currentThread(); int c = getState(); if (c == 0) { //重点是这里不同，不会直接去通过CAS获取锁，而是调用hasQueuedPredecessors方法查看阻塞队列中有没有前驱节点, //这个方法是核心，如果阻塞队列中当前线程节点的前面有节点，那么这里不会进去，直接会走下面的else if //如果前面没有节点，那么说明当前阻塞队列为null或者只有当前线程这一个节点，那就可以获取CAS修改state，获取锁成功 if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; } //判断阻塞队列中当前线程节点前面有没有节点？ public final boolean hasQueuedPredecessors() { Node t = tail; // Read fields in reverse initialization order Node h = head; Node s; //注意，头节点head指向的是哨兵节点 //如果头节点和尾节点一样即h==t，前面博客画图都说了都指向哨兵节点，此时阻塞队列为空，没有前驱节点，就返回false //如果h != t同时(s = h.next) == null，说明阻塞队列中哨兵节点后面正在插入一个节点，此时表示有前驱节点，返回true //如果h != t同时(s = h.next) != null，而且s.thread != Thread.currentThread()，说明哨兵节点后面有一个节点，而且这个节点还不是当前线程节点 //也就是说有前驱节点，返回true return h != t && ((s = h.next) == null || s.thread != Thread.currentThread()); }

五.其他一些方法

　　上面我们看了公平策略和非公平策略的实现方式，其实没什么，比较容易，继续看看一些其他的方法，这些方法是通用的；

　　1.lockInterruptibly()方法

//前面说过加了Interruptibly表示如果当前线程在调用该方法时，其他线程调用了当前线程的interrupt()方法的时候，那么
//当前线程就会抛出InterruptedException异常，我们可以看看内在的机制是怎么实现的
public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

public final void acquireInterruptibly(int arg) throws InterruptedException {
    //如果当前线程被中断，就抛出异常
    if (Thread.interrupted())
        throw new InterruptedException();
    //尝试获取资源，这里分为公平策略和非公平策略，前面已经说过了;
    //获取资源失败的话，就调用AQS可被中断的方法
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);
}

　　2.tyLock()方法

//很明显这个tryLock方法是非公平策略
public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}
//这个方法在前面说非公平策略的时候tryAcquire方法调用的也是这个方法
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;
}

　　3.tryLock(long timeout, TimeUnit unit)方法

　　这个方法和上面的方法不一样的就是可以设置超时时间，其实和前面说的也差不多，就是多了一个时间的判断，这个也是会对线程中断有响应的；

public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

public final boolean tryAcquireNanos(int arg, long nanosTimeout) throws

栏目列表