java 锁 ReentrantLock源码分析

public class ReentrantLock implements Lock, java.io.Serializable

内部实现三个类，Sync,FairSync,NonfairSync

默认构造函数，创建非公平锁

//默认构造函数，创建非公平锁
public ReentrantLock() {
        sync = new NonfairSync();
    }
//传参数指定
public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
//加锁操作
public void lock() {
        sync.lock();
    }

非公平锁的lock()方法

    //非公平锁实现
    final void lock() {
            //执行CAS操作，判断state是否为0，如果为0则更新为1，并返回true，否则false
            if (compareAndSetState(0, 1))
                //成功则将独占锁线程设置为当前线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //否则再次请求同步状态
                acquire(1);
        }

也就是说，通过CAS机制保证并发的情况下只有一个线程可以成功将state设置为1，获取到锁；

此时，其它线程在执行compareAndSetState时，因为state此时不是0，所以会失败并返回false，执行acquire(1);

AQS的acquire方法

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

tryAcquire在AQS未具体实现，所以在ReentrantLock内部类实现

非公平锁的tryAcquire

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

非公平所NonfairSync父类的nonfairTryAcquire

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //获取volatile类型的state
            int c = getState();  
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {   
                //重入锁重复加锁，status+1，同一线程不会有问题
                int nextc = c + acquires;
                if (nextc < 0) // 溢出
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

 

 

unlock 释放锁

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


//AQS的release
 public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                //唤醒后继节点的线程
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

内部类Sync的tryRelease

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            //c为0表示释放成功
            if (c == 0) {
                free = true;
                //设置自身为null
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

unparkSuccessor(h)的作用的唤醒后续的节点：

private void unparkSuccessor(Node node) {
        /*
         * 如果waitStatus小于0，置0当前线程所在的节点状态，允许失败
         */
        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);
    }