标签:tran dia 存在 flow less rac == help extend
本篇博文主要记录ReentranctLock内部实现原理。
ReentrantLock和Synchronized关键字相比,使用起来比较灵活。如何使用ReentranctLock就不多讲了,这里主要记录ReentrantLock的内部实现原理。
首先看下ReentrantLock的类继承结构, 如下图:
ReentrantLock内部有三个内部类: Sync, FairSync, NonfairSync. 源码如下:
Sync:
abstract static class Sync extends AbstractQueuedSynchronizer { private static final long serialVersionUID = -5179523762034025860L; /** * Performs {@link Lock#lock}. The main reason for subclassing * is to allow fast path for nonfair version. */ abstract void lock(); /** * 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(); 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; } protected final boolean tryRelease(int releases) { int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; if (c == 0) { free = true; setExclusiveOwnerThread(null); } setState(c); return free; }
... }
FairSync:
static final class FairSync extends Sync { private static final long serialVersionUID = -3000897897090466540L; final void lock() { acquire(1); } /** * Fair version of tryAcquire. Don‘t grant access unless * recursive call or no waiters or is first. */ protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { 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; } }
NonfairSync:
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); } }
FairSync实现了公平锁逻辑, NonfairSync实现的是非公平锁的逻辑。 下面看下最常使用的非公平锁的实现。
NonfairSync.lock()方法,首先基于CAS设置AQS中的state,如果返回true, 说明获取成功,此时将排他线程设置为当前线程。如果返回false, 说明获取失败,调用acquire(1)方法。acquire()方法在AQS中,代码如下:
public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }
在acquire中首先再次获取锁, 如果获取失败, 则调用addWaiter()方法,将当前线程加入CHL队列。CHL队列结构如下:
加入队列后,然后调用方法acquireQueued(), 代码如下:
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); } }
在acquireQueued()方法中,首先判断当前节点的前置节点是不是头结点,如果是头结点,则尝试获取锁,获取成功,则当前节点设置为头结点。否则判断是否应该讲当前节点对应的线程挂起, 如果前一个前一个节点的status是SIGNAL, 则说明需要将当前节点挂起。调用parkAndCheckInterrupt()方法挂起当前节点的线程。
上面是非公平锁的lock()逻辑,公平锁和非公平锁的,区别主要是公平锁在获取之前,首先需要判断是否存在前置节点,如果存在前置节点,则需要等待。我们看到FairSync中的tryAcquire()方法中,首先调用了hasQueuedPredecessors()方法,判断是否存在前置节点。
标签:tran dia 存在 flow less rac == help extend
原文地址:http://www.cnblogs.com/NewMan13/p/7787021.html