先来简单通俗的描述一下  ReentrantLock     和 ReentrantReadWriteLock

   其实原理非常类似，都是通过判断   ReentrantLock  里面 有个state  ，

   ReentrantReadWriteLock  可以看成有两个 state ,一个是read_state  ,一个是write_state  

   这些东西都是通过这些state 的值进行CAS 操作加一，如果操作成功，则获取执行权限，否则放入阻塞队列呆着，并设置中断    标识，让线程停止运行

  当前获取的执行权限的 线程 执行unlock(),后，会将 state 进行CAS减一，如果state 变成0，则唤醒阻塞列队头部的线程，

 不管是公平锁还是非公平锁，都是唤醒挨着队列头的线程。公平和非公平的区别在于新进来的线程刚开始执行lock(),或者    trylock();的时候是否允许其执行CAS加一操作。

 

读写锁也是一样，只不过维护了两个state而已，哈哈哈，万变不离其宗。接下来详细介绍追涨源码

Lock lock =new ReentrantLock();
        lock.lock();
        lock.lock();

        lock.unlock();

     我们先来debug 看看这个对象里面有那些成员，

    只有一个

 private final Sync sync;

它是一个抽象内部类，sync 有两个实现，一个是公平锁，一个非公平锁

abstract static class Sync extends AbstractQueuedSynchronizer｛｝

他没有定义任何属性，他继承 AbstractQueuedSynchronizer

private transient Thread exclusiveOwnerThread; 哪个线程持有当前的锁

private volatile int state;     

volatile Node prev; 上一个

volatile Node next;下一个

private transient volatile Node head; 头节点

private transient volatile Node tail; 尾节点

很明显，和名字一样，抽象队列同步器

是一个双向队列，

 

Sync是一个抽象内部类，sync 有两个实现，一个是公平锁，一个非公平锁

static final class NonfairSync extends Sync

static final class FairSync extends Sync 

 

lock.lock(); 的时候就是将这个state 的值通过CAS原子性的增加1，多次调用则继续加一，则就是可重入锁。

这个这段开始这个字段为0 ，所有的线程都尝试对其修改（也就是我们说的加锁，其实本质就是修改其值），通过CAS算法修改其值，了解CAS算法的人都知道，一旦这个值被人修改成，其他人如果还拿原来的值当作预定值都无修改成功。

第一个线程修改成功后成功执行，其他那些没有成功的线程放入队列中排队，但是他们依然会不断的尝试获取锁。

compareAndSetState(0, 1)，其他那些没有获得锁的线程会不断的调这个方法，自旋 for(;;)的调用这个方法，除非 占有当前锁的线程，也就是队列最前面的线程，也是exclusiveOwnerThread引用的线程，释放锁，所谓释放锁就是对这个值进行减一，当state值减到0的时候，另外那些线程的compareAndSetState(0, 1)才有可能成功。这里涉及到公平锁和非公平锁的概念。如果是非公平锁，就是我们上面讲的，所有人都可以试图执行compareAndSetState(0, 1)方法，不分队列的前面还是后面，如果是公平锁，就会进行判断，当前这个节点是否是队列的头，就是它的prev是否存在，如果前面还有人，则不能执行compareAndSetState(0, 1)，这就叫公平，先到的人有优先权。

还是对着代码讲有说服力，我们来看看源码，从方法名看就知道是非公平锁。

       final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {  //等于0，大家马上看见了，所有人都试图去修改其值，并且设置自己为当前锁的获得者。
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {

     //如果不等于0，并且自己就是当前锁的拥有者，则继续加锁，继续对这  个这段加1，就是重入锁概念。
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

  

我们再看看公平锁的源码：

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

这逻辑和上面的没多大区别，就是去获取锁之前加了!hasQueuedPredecessors()判断当前是否是头节点，或者并且是当前锁的拥有者

 

Lock lock =new ReentrantLock(true); 这样申明的是公平锁，

Lock lock =new ReentrantLock(); 这样声明的是非公平锁，我们看看这两种声明有啥不同。

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

这样可以看见声明的时候可以生成两种不同的实现，

 /**
     * Sync object for fair locks
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

这是公平锁的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);
        }

这是非公平锁的lock();

写的非常清楚，非公平锁，一进来就调用compareAndSetState(0, 1)去获得锁。

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

这个方法显示，如果获得失败，则添加到等待队列中，

addWaiter(Node.EXCLUSIVE), arg)

这个方法往队列的尾部添加一个节点。

 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);
        }
    }

自旋获取锁，

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

 

我们来看看 获取失败 ，要做什么

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

 

selfInterrupt();

 static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }

public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // Just to set the interrupt flag
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }

这方法就是设置一个中断标识，完了。这个线程就休息了。

接下来带头大哥执行完了，state 变回了0,要唤醒哪些线程呢，我们来看看源码，

public void unlock() {
        sync.release(1);
    }

 public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            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;
        }

将state 减一，然后判断当前线程是否是获得锁的线程，设置获得锁的线程为null，完事。

 

public final boolean release(int arg) {
        if (state ==0) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

 private void unparkSuccessor(Node node) {

        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

设置一下当前节点的状态并且唤醒下一个节点线程