【Java 并发】【九】【AQS】【四】ReentrantLock是怎么基于AQS实现独占锁的

public class ReentrantLockTest extends Thread{
    // 共享变量
    private static int num = 0;
    // 互斥锁 这个例子如果去掉static会发生什么呢？ 这把锁就不是同一把了，就会失效导致结果不对
    private static ReentrantLock lock = new ReentrantLock();
    // 累加
    private void add() {
        try {
            // 先获取锁
            lock.lock();
            num++;
        } finally {
            // 最后释放锁
            lock.unlock();
        }
    }
    @Override
    public void run() {
        for (int i=0; i<10000; i++) {
            add();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        // 创建两个线程并启动
        ReentrantLockTest demo1 = new ReentrantLockTest();
        ReentrantLockTest demo2 = new ReentrantLockTest();
        demo1.start();
        demo2.start();
        // 等待两个线程都执行完
        demo1.join();
        demo2.join();
        // 打印一下结果
        System.out.println(ReentrantLockTest.num);
    }
}

static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        // 这里的acquire方法其实就是AQS的acquire方法
        acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        // 获取当前线程
        final Thread current = Thread.currentThread();
        // 判断资源是否有人加锁，c == 0 没人加锁，c > 0 表示有人加锁了
        int c = getState();
        // c == 0 表示没人加锁
        if (c == 0) {
            // hasQueuedPrecessors这里时判断AQS的等待队列是否有人在等待
            // 其实公平锁和非公平锁实现的精髓就在这里，
            // 公平锁如果发现AQS中等待队列有人在等待，那么直接去排队，即时资源时空的也不争抢
            if (!hasQueuedPredecessors() &&
                // 如果AQS队列没线程在排队，则CAS开始争抢锁
                compareAndSetState(0, acquires)) {
                // 争抢成功则设置加锁的线程是自己
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        // 如果上面 c > 0 说明有人加锁了
        // 这里就获取当前加锁的线程是谁，如果加锁的是自己，则直接重入
        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 void unlock() {
    sync.release(1);
}

public final boolean release(int arg) {
    // 1. 这里会调用子类的tryRelease方法，实际去释放锁
    if (tryRelease(arg)) {
        Node h = head;
        // 2. 释放锁成功，唤醒后续AQS等待队列中等待的线程
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    // 直接将释放锁的次数减少releases次
    // 也就是你加锁多少次，就释放多少
    // 当state == 0 的时候说明锁已经空闲了，没人持有了
    int c = getState() - releases;
    // 这里释放之前判断之前是不是自己加锁的
    // 如果自己之前没加锁，不能胡乱释放，直接抛出异常
    // 谁加的锁，谁才能释放
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 当c == 0 说明锁已经完全释放了
    if (c == 0) {
        free = true;
        // 设置加锁的线程为null，表示没人加锁了
        setExclusiveOwnerThread(null);
    }
    // 设置state = 0，锁空闲了，让别的线程可以加锁
    setState(c);
    // free = true表示锁释放了，完全空闲了
    return free;
}

final void lock() {
    // 这里上来就直接尝试加锁，不管资源是不是空的，不管有没有人在等待
    // 非公平锁看到，上来就抢
    if (compareAndSetState(0, 1))
        // 抢夺成功之后，设置是自己加锁，然后就完事了
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

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

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

final boolean nonfairTryAcquire(int acquires) {
    // 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取资源state的值，state > 0 表示已经有人加锁了
    // state = 0表示没人加锁，锁是空闲的
    int c = getState();
    // 如果c == 0 没人加锁，马上就去竞争锁，不管有没有人在等待
    if (c == 0) {
        // CAS尝试竞争锁
        if (compareAndSetState(0, acquires)) {
            // 加锁成功，设置加锁的线程是自己，
            // 这里的setExclusiveOwnerThread就是设置是哪个线程加锁的
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 如果上面c != 0 ，说明有人加锁了；这里判断之前加锁的线程是不是自己
    // 如果是自己的话，直接就重入，直接把自己加锁的次数增加就可以了
    // 如果不是自己加锁，说明是别人加锁了，此时就需要进入AQS的等待队列等待
    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;
}

public void unlock() {
    // 调用到AQS的release方法释放
    sync.release(1);
}

public final boolean release(int arg) {
    // 调用到子类的tryRelease方法
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}