Lock - ReentrantLock - 《Java 基础》

1 示例
2 类结构关系
3 NonfairSync实现原理
4 FairSync 实现原理
- 4.1 tryAcquire
- 4.2 hasQueuedPredecessors

1 示例

public class ReentrantLockTest {
    public static void main(String[] args) {
        ThreadDemo demo = new ThreadDemo();
        ThreadDemo2 lockDemo = new ThreadDemo2();
        Thread t = new Thread(demo);
        Thread t2 = new Thread(demo);
        Thread tt = new Thread(lockDemo);
        Thread tt2 = new Thread(lockDemo);
        t.start();
        t2.start();
        tt.start();
        tt2.start();
    }
}
class ThreadDemo implements Runnable {
    volatile int num = 0;
    ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        lock.lock();
        for (int i = 0; i < 1000000; i++) {
            num++;
        }
        System.out.println("加锁操作后，num:" + num);
        lock.unlock();
    }
}
class ThreadDemo2 implements Runnable {
    int num = 0;
    @Override
    public void run() {
        for (int i = 0; i < 1000000; i++) {
            num++;
        }
        System.out.println("不加锁，num:" + num);
    }
}

输出：

不加锁，num:1123472
加锁操作后，num:1000000
不加锁，num:1979071
加锁操作后，num:2000000

2 类结构关系

ReentrantLock 是可重入的独占锁只能有线程可获取该锁，其获取该锁的线程会被阻塞而被放入该锁的阻塞队列里面。

ReentrantLock 最终还是使用 AQS 来实的，并且根据参数来决定其内部是一个公平还是非公平锁，默认是非公平锁。

//无参构造，默认是非公平锁
public ReentrantLock() {
        sync = new NonfairSync();
    }
   //根据参数来决定其内部是一个公平还是非公平锁
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

其中 Sync 类直接继承自 AQS 它的子类 No fairSy FairSync 分别实现了获取锁的非公平与公平策略。
在这里， AQS state 态值表示线程获取该锁的可重入次数在默认情况下， state的值为表示当前锁没有被任何线程持有线程第次获取该锁会尝试使用 CAS 设置 state 的值为，如果 CAS 成功则当前线程获取了该锁，然后记录该锁的持有者为当前线程在该线程没有释放锁的情况下第次获取该锁后，状态值被设置为这就是可重入次数在该线程释放该锁时，会尝试使用 CAS 让状态值减如果减后状态值为 0，则当前线程释放该锁。

3 NonfairSync实现原理

3.1 lock

public void lock() {
        sync.lock();
    }

final void lock() {
            if (compareAndSetState(0, 1))
                //CAS成功，设置该锁持有者是当前线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //CAS失败，尝试获取锁
                acquire(1);
        }

3.2 acquire

   public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            //获取锁失败，会把当前线程放入AQS 阻塞队列
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

3.3 tryAcquire

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) { //当前AQS state状态值是0（无锁）；
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);  //CAS成功，设置该锁持有者是当前线程
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {  //当前线程是该锁持有者
                int nextc = c + acquires;  //状态值加1
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;  //都不是，返回false,丢入队列
        }

3.4 unlock

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

3.5 tryRelease

此方法为抽象类Sync的final方法，公平锁和非公平锁公用此方法

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;  //重入次数减1
      //如果当前线程不是锁持有者，抛异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {  //如果当前可重入次数为0，清空锁
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);  //重入次数减1
            return free;
        }

4 FairSync 实现原理

公平锁的话只需要看 FairSync 重写 tryAcquire方法。

4.1 tryAcquire

  protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {  //当前AQS state状态值是0（无锁）；
                // 只有队列为空时，才会通过CAS尝试获取锁
                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;
        }
    }

4.2 hasQueuedPredecessors

public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
    //如果 h==t 说明当前队列为空，直接返回 false
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

在如上代码中，如果当前线程节点有前驱节点则返回住时，如果当前 AQ 队列为空或者当前线程节点是 AQS 第一个节点则返回 false 。其中如果 h==t 说明当前队列为空，直接返回 false ；如果 h!=t 并且 ==null 则说明有一个元素将要作为 QS 第一个节点入队列（回顾前面的内容， enq 数的第一个元素入队列是两步操作：首先建一个哨兵头节点，然后将第一元素插入哨兵节点后，那么返回 true ，如果 h!=t 并且 s!=null和s.thr巳ad != Thread.cunentThread（）则说明队列面的第个元不是当前线程，那么返回true