JavaSE-多线程（5.3）- ReentrantLock （源码解析，非公平模式）

JavaSE-多线程（5.3）- ReentrantLock （源码解析，非公平模式）

承接上文：JavaSE-多线程（5.3）- ReentrantLock （源码解析，公平模式）

举例

还是以上文中测试类举例：

package com.hs.example.base.multithread.reentantlock;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;

public class FairLockAndNonFairLockTest {

    static class Task implements Runnable {
        private final ReentrantLock lock;
        private volatile int count = 0;

        public Task(boolean fair) {
            this.lock = new ReentrantLock(fair);
        }

        @Override
        public void run() {
            for (int i = 0; i < 3; i++) {
                doTask();
            }
        }

        private void doTask() {
            lock.lock();
            try {
                System.out.println("任务开始。。。, 线程：" + Thread.currentThread().getName() + " , count=" + count);
                count++;
                sleep(500);
                System.out.println("任务结束。。。, 线程：" + Thread.currentThread().getName() + " , count=" + count);
                printQueuedThreads(lock);
            } finally {
                lock.unlock();
            }
        }
    }

    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public static void printQueuedThreads(ReentrantLock lock) {
        Class<ReentrantLock> reentrantLockClass = (Class<ReentrantLock>) lock.getClass();
        try {
            // getQueuedThreads 方法访问权限是 protected ，所以通过反射方式访问
            Method getQueuedThreads = reentrantLockClass.getDeclaredMethod("getQueuedThreads");
            getQueuedThreads.setAccessible(true);
            // 获取 aqs 中的线程队列
            List<Thread> list = (List<Thread>) getQueuedThreads.invoke(lock);
            // 看 getQueuedThreads 方法源码可知，它的顺序是从tail开始 加入list的，这里给它倒过来，从 head 开始
            Collections.reverse(list);
            System.out.println(list);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        // 非公平模式 
        Task task = new Task(false);
        for (int i = 0; i < 5; i++) {
            new Thread(task, "t" + (i + 1)).start();

            // 稍微延迟启动，让线程按顺序创建和启动
            sleep(10);
        }
    }
}

程序运行结果：

任务开始。。。, 线程：t1 , count=0
任务结束。。。, 线程：t1 , count=1
[Thread[t2,5,main], Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t1 , count=1
任务结束。。。, 线程：t1 , count=2
[Thread[t2,5,main], Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t1 , count=2
任务结束。。。, 线程：t1 , count=3
[Thread[t2,5,main], Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t2 , count=3
任务结束。。。, 线程：t2 , count=4
[Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t2 , count=4
任务结束。。。, 线程：t2 , count=5
[Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t2 , count=5
任务结束。。。, 线程：t2 , count=6
[Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t3 , count=6
任务结束。。。, 线程：t3 , count=7
[Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t3 , count=7
任务结束。。。, 线程：t3 , count=8
[Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t3 , count=8
任务结束。。。, 线程：t3 , count=9
[Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t4 , count=9
任务结束。。。, 线程：t4 , count=10
[Thread[t5,5,main]]
任务开始。。。, 线程：t4 , count=10
任务结束。。。, 线程：t4 , count=11
[Thread[t5,5,main]]
任务开始。。。, 线程：t4 , count=11
任务结束。。。, 线程：t4 , count=12
[Thread[t5,5,main]]
任务开始。。。, 线程：t5 , count=12
任务结束。。。, 线程：t5 , count=13
[]
任务开始。。。, 线程：t5 , count=13
任务结束。。。, 线程：t5 , count=14
[]
任务开始。。。, 线程：t5 , count=14
任务结束。。。, 线程：t5 , count=15
[]

程序运行结果与公平模式下对比，各个线程将各自任务执行完成后，才执行下一个线程的任务。

分析

刚开始时还是线程 t1 获取锁，线程 t2、t3、t4、t5 加入等待队列。当 t1 线程 doTask 任务执行一次循环后，调用 unlock 方法，此时 t1 处于 running 状态，t1 线程继续调用 lock 方法，如下：

final void lock() {
    // 非公平锁会执行抢占锁，
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 而公平锁直接调用这个方法，将线程加入队列中
        acquire(1);
}

线程 t1 调用 lock.unlock(); 方法后，会唤醒线程 t2 ，具体代码为 LockSupport.unpark(s.thread); ，但是线程 t2 不是立马进入running 状态，会从waitting 状态进入 ready 状态，待进入running状态后才继续执行循环体。

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

线程状态可查看文章：线程状态
由于此时 t1 线程已经是 running 状态，而 t2 是 ready 状态，所以 t1 优先获取到了锁，所以 t1 线程继续执行循环体，而 t2 线程进入 running 状态后 由于获取锁失败又会进入 waitting 状态。。