java多线程---ReentrantLock源码分析

　　ReentrantLock源码分析

　　基础知识复习

　　synchronized和lock的区别

　　synchronized是非公平锁，无法保证线程按照申请锁的顺序获得锁，而Lock锁提供了可选参数，可以配置成公平锁，也可以配置成非公平锁。通常来说，非公平锁的效率比公平锁要高。

　　一个线程使用syn获取锁，除非该线程成功获取到锁，否则将一直阻塞住。而Lock锁提供了lockInterruptibly()接口，提供了可中断的操作

　　带超时时间的锁。Lock锁提供了tryLock(long time, TimeUnit unit)带超时时间的获取锁的接口，在等待指定时间后，如果获取不到锁，则放弃获取锁

　　自动释放锁。如果用syn加锁，当发生异常时(比方运行时异常)，那么jvm会自动释放掉线程持有的锁，而lock锁则不会主动释放，除非调用了unlock接口，因此使用lock锁时有可能导致死锁

　　在ReentrantLock上可以绑定多个Condition条件，也就是可以拥有多个等待队列，比如在实现生产者消费者的时候，使用一个队列(锁的队列)存放等待 队列(生产者消费者的队列)有元素的消费者，使用另一个队列(锁的队列)存放等待 队列not full的生产者，相比较synchronized和wait notify而言，避免了错误的唤醒生产者或者消费者的开销

　　ReentrantLock 基础分析

　　ReentrantLock是lock的一个实现类，独占锁。首先看一下ReentrantLock的内部属性

　　private final Sync sync;

　　1

　　发现在只有一个Sync类型的属性，这个Sync是AQS的一个抽象类如下：

　　abstract static class Sync extends AbstractQueuedSynchronizer {

　　private static final long serialVersionUID = -5179523762034025860L;

　　abstract void lock();

　　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;

　　}

　　....

　　同时在ReentrantLock 内部，实现了Sync2个不同的类，一个是NonfairSync(非公平锁),一个是FairSync(公平锁)。也就是在一开头，synchronized和lock的区别的第一点，Lock可以创建2种不同的锁，根据传入的参数。

　　如下源码

　　//默认的ReentrantLock无参构造函数，是非公平锁

　　public ReentrantLock() {

　　sync = new NonfairSync();

　　}

　　//当传入fasle时，就创建了公平锁。

　　public ReentrantLock(boolean fair) {

　　sync = fair ? new FairSync() : new NonfairSync();

　　}

　　AbstractQueuedSynchronizer

　　那么Sync的父类是AQS，并发包中的锁底层就是使用了AQS：AbstractQueuedSynchronizer。所以来看一下AQS，那么首先来看下属性：

　　//这个是父类AbstractOwnableSynchronizer中的属性，标识了独占模式下获取锁的是哪一个线程

　　private transient Thread exclusiveOwnerThread;

　　//AQS的数据结构是FIFO的双向队列

　　//头部节点

　　private transient volatile Node head;

　　//尾部节点

　　private transient volatile Node tail;

　　//同步状态值

　　private volatile int state;

　　//设置这里使用CAS来更新 主要用于对state的更新

　　private static final Unsafe unsafe = Unsafe.getUnsafe();

　　private static final long stateOffset;

　　private static final long headOffset;

　　private static final long tailOffset;

　　private static final long waitStatusOffset;

　　private static final long nextOffset;

　　可以看到有头部节点和尾部节点外，还有一个同步状态值state,该属性在不同的锁中，代表了不同的含义。

　　在ReentrantLock中，state可以用来表示当前线程获取锁的可重入次数

　　对与ReentrantReadWriteLock来说，高16位代表了读锁，也就是读锁的次数，低16位代表了写锁的可重入次数

　　在Semaphore中，state代表了可用信号的个数

　　在countdownlatch中，state用来表示计数器当前的值

　　所以在ReentrantLock 中 state用来表示当前线程获取锁的可冲入次数。当没有线程持有锁的时候，state为0，当有一个线程获取锁时，state为1。然后当前线程需要再次获取锁时，发现自己已经是锁的持有者，state+1

　　看下AQS的Node：

　　//是在获取共享资源时放入队列

　　static final Node SHARED = new Node();

　　//是在获取独占资源时放入对列的

　　static final Node EXCLUSIVE = null;

　　//线程被取消

　　static final int CANCELLED = 1;

　　//线程需要被唤醒

　　static final int SIGNAL = -1;

　　//线程在条件队列里面等待

　　static final int CONDITION = -2;

　　//释放共享资源时通知其他节点

　　static final int PROPAGATE = -3;

　　//表示等待的状态，可以为以上几个值

　　volatile int waitStatus;

　　volatile Node prev;

　　volatile Node next;

　　//在队列中的线程

　　volatile Thread thread;

　　Node nextWaiter;

　　在已知队列中的节点是这样的结构情况下，来看下何如进行获取资源

　　//根据源码中的英文来翻译，就是获取独占资源时调用该方法，

　　//也就是使用tryAcquire来改变state的值，如果失败就会把线程封装成Node.EXCLUSIVE放入队列尾部并挂起

　　public final void acquire(int arg) {

　　if (!tryAcquire(arg) &&

　　acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

　　selfInterrupt();

　　}

　　//其中 tryAcquire是在实现类中具体实现的

　　对应的释放资源

　　//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;

　　}

　　以上2个release和acquire，的最常见的实现例子就是Lock中的unlock和lock。但是在AQS源码中还存在着一个类似的方法，acquireInterruptibly ，这个方法和acquire功能一样，但是带Interruptibly 的方法，就是可以对中断进行响应。如果该线程在等待过程中被中断了，那么带Interruptibly 的方法就会抛出异常，也会终端。否则不会。对应了一开始的第二条，lockInterruptibly()可以对中断进行响应。

　　再来看一下在AQS中，是怎么进行加入队列操作的。

　　//有2种方式，如果尾部节点不为空，就直接加入封装好的node，为空则调用enq()加入队列

　　private Node addWaiter(Node 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;

　　if (compareAndSetTail(pred, node)) {

　　pred.next = node;

　　return node;

　　}

　　}

　　enq(node);

　　return node;

　　}

　　private Node enq(final Node node) {

　　for (;;) {

　　Node t = tail;

　　if (t == null) { // Must initialize

　　//加入一个空的node为哨兵节点

　　if (compareAndSetHead(new Node()))

　　tail = head;

　　} else {

　　node.prev = t;

　　if (compareAndSetTail(t, node)) {

　　t.next = node;

　　return t;

　　}

　　}

　　}

　　}

　　也就是说，当队列为空时，在加入第一个节点的时候，会先加入一个哨兵节点。

　　ReentrantLock 中的lock

　　这里分为2中情况分析lock()方法，之前说过ReentrantLock中的Sync有非公平和公平2中模式。又结合AQS的源码分析，所以我们知道区别在于FairSync 和NonfairSync 2个类中的 tryAcquire 实现不同。

　　FairSync 公平情况如下：

　　protected final boolean tryAcquire(int acquires) {

　　final Thread current = Thread.currentThread();

　　int c = getState();

　　//当state为0时，就标识空闲，可以被获取

　　if (c == 0) {

　　//hasQueuedPredecessors是公平策略，

　　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;

　　}

　　可以看到对state的修改都是运行了CAS来更新，同时，在修改state的基础上，使用了公平策略hasQueuedPredecessors是在AQS中的方法

　　//判断当前节点是否是队列的第一个节点，如果当前节点有前驱结点返回true，当前队列为空或者当前节点是第一个节点则返回false

　　public final boolean hasQueuedPredecessors() {

　　Node t = tail;

　　Node h = head;

　　Node s;

　　return h != t &&

　　((s = h.next) == null || s.thread != Thread.currentThread());

　　}

　　这里最后的判断可以分开来看，h==s则是当前队列为空，直接返回false，如果h!=s且s==null则是，说明有一个元素将要作为AQS的第一个节点入队列，那么返回true，如果，s.thread != Thread.currentThread()) 就代表，第一个元素就不是当前的线程，返回true。

　　NonfairSync 非公平情况如下郑州不孕不育医院:http://www.zzfkyy120.com/

　　protected final boolean tryAcquire(int acquires) {

　　return nonfairTryAcquire(acquires);

　　}

　　//非公平获取

　　final boolean nonfairTryAcquire(int acquires) {

　　final Thread current = Thread.currentThread();

　　int c = getState();

　　if (c == 0) {

　　//缺少了校验公平的策略，直接对state进行修改

　　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;

　　}

　　所以按照以上Lock的逻辑，lockInterruptibly便是调用了acquireInterruptibly的方法来获取资源

　　public final void acquireInterruptibly(int arg)

　　throws InterruptedException {

　　//判断线程的状态

　　if (Thread.interrupted())

　　throw new InterruptedException();

　　if (!tryAcquire(arg))

　　doAcquireInterruptibly(arg);

　　}

　　ReentrantLock 中的unlock

　　ReentrantLock 中的unlock，是没有策略之分，在Snyc中就实现了方法

　　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;

　　}

　　unlock的代码就比较好读了，先判断lock的持有线程与当前线程是否一致，然后是的话，就把state和持有线程清空。最后在AQS中，会移除该节点

　　当然在AQS中，还存在一个条件队列，在后续文章再谈。

　　下面是ReentrantLock 的一个例子，模拟领取优惠卷的情况

　　public class ReenTrantLockDemo extends Thread{

　　//模拟优惠卷

　　private static List array = new ArrayList<>();

　　private static Lock lock = new ReentrantLock();

　　public Integer get(){

　　lock.lock();

　　try {

　　Integer o= array.get(0);

　　array.remove(o);

　　return o;

　　}catch (Exception e){

　　System.out.println("获取出错");

　　}finally {

　　lock.unlock();

　　}

　　return -1;

　　}

　　@Override

　　public void run() {

　　Integer a = get();

　　System.out.println("获取到的优惠卷编号为"+a);

　　}

　　public static void main(String[] args) {

　　for(int i=0;i<10;i++){

　　array.add(i);

　　}

　　ReenTrantLockDemo reenTrantLockDemo = new ReenTrantLockDemo();

　　ExecutorService service = Executors.newCachedThreadPool();

　　ReenTrantLockDemo demo = new ReenTrantLockDemo();

　　for (int i = 0; i < 10; i++) {

　　service.submit(demo);

　　}

　　service.shutdown();

　　}

　　}

　　结果为

　　获取到的优惠卷编号为3

　　获取到的优惠卷编号为2

　　获取到的优惠卷编号为6

　　获取到的优惠卷编号为5

　　获取到的优惠卷编号为1

　　获取到的优惠卷编号为0

　　获取到的优惠卷编号为4

　　获取到的优惠卷编号为8

　　获取到的优惠卷编号为7

　　获取到的优惠卷编号为9

　　10

　　去掉lock的结果为：

　　获取到的优惠卷编号为0

　　获取到的优惠卷编号为5

　　获取到的优惠卷编号为0

　　获取到的优惠卷编号为0

　　获取到的优惠卷编号为0

　　获取到的优惠卷编号为7

　　获取到的优惠卷编号为4

　　获取到的优惠卷编号为8

　　获取到的优惠卷编号为0

　　获取到的优惠卷编号为6

　　名词解释

　　公平锁与非公平锁 ：是否按照线程进入阻塞队列的顺序来执行