JDK8 LockSupport源码理解

LockSupport是java并发体系下阻塞线程的基础。通过理解原理可以理解锁如何阻塞线程，以及锁源码为何要清除中断标记并返回中断标识

一、先看Unsafe中park和unpark的大概原理

  虚拟机使用的Unsafe为每个线程维护一个许可变量_counter。它有4个特点：

• _counter默认为0，unpark会将其变为1
• park会尝试将_counter从1变为0，如果不为1则阻塞。
• 可以先unpark再park，这时的park不会再阻塞
• 提前设置中断标记，多次park也不会被阻塞

/**
 * Unsafe的park和unpark大概原理
 */
class UnsafeDemo {
    /**
     * 许可标志位，为0时无许可，为1时有许可
     */
    private int _counter;

    /**
     * 初始化无许可
     */
    UnsafeDemo(){
        _counter= 0;
    }

    /**
     * 阻塞，直到获取许可或者线程被中断
     */
    public void park() {
        while (_counter!= 1){
            if (Thread.currentThread().isInterrupted()){
                break;
            }
        }
        _counter= 0;
    }

    /**
     * 设置拥有许可
     */
    public void unpark() {
        _count = 1;
    }
}

一个简单的例子：

public static void testPark() {
        Thread.currentThread().interrupt();
        LockSupport.park();
        System.out.println(1);
        System.out.println(Thread.interrupted());
        LockSupport.park();
        System.out.println(2);
    }

结果：

• 提前设置了中断标记，发现第一次park未被阻塞。
• 将中断标记清除，第二次被阻塞住了。

二、LockSupport源码

都是基于Unsafe的park和unpark的操作。

其中，

• blocker的作用是记录阻塞时的信息，用于允许监视和诊断工具确定线程被阻塞的原因
• LockSupport不需要获取同步锁，直接就能阻塞某线程和释放某线程

package java.util.concurrent.locks;

public class LockSupport {
    /**
     * 私有构造，无法被实例化
     */
    private LockSupport() {}

    /**
     * 设置blocker
     * 将线程t的parkBlocker字段的值更新为arg
     */
    private static void setBlocker(Thread t, Object arg) {
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

    /**
     * 释放许可，使线程继续运行。
     * 如果线程没被阻塞，则下次park不会阻塞该线程？
     */
    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }

    /**
     * 阻塞线程
     */
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        // 设置blocker，用于记录阻塞情况
        setBlocker(t, blocker);
        // 阻塞线程，获取许可
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }

    /**
     * 带blocker的相对时间阻塞
     */
    public static void parkNanos(Object blocker, long nanos) {
        if (nanos > 0) {
            Thread t = Thread.currentThread();
            setBlocker(t, blocker);
            UNSAFE.park(false, nanos);
            setBlocker(t, null);
        }
    }

    /**
     * 带blockers的绝对时间阻塞
     */
    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        setBlocker(t, null);
    }

    /**
     * 获取blocker
     */
    public static Object getBlocker(Thread t) {
        if (t == null)
            throw new NullPointerException();
        return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
    }

    /**
     * 无限等待其它线程将该线程unpark 或 中断该线程
     */
    public static void park() {
        UNSAFE.park(false, 0L);
    }

    /**
     * 指定等待时间
     */
    public static void parkNanos(long nanos) {
        if (nanos > 0)
            UNSAFE.park(false, nanos);
    }

    /**
     * 阻塞到指定时刻
     */
    public static void parkUntil(long deadline) {
        UNSAFE.park(true, deadline);
    }

    /**
     * 这个方法是由于多线程随机数生成器ThreadLocalRandom的package访问权限限制不能被这个包下的类使用，
     * 复制了一份实现出来，在StampedLock中被使用
     */
    static final int nextSecondarySeed() {
        int r;
        Thread t = Thread.currentThread();
        if ((r = UNSAFE.getInt(t, SECONDARY)) != 0) {
            r ^= r << 13;   // xorshift
            r ^= r >>> 17;
            r ^= r << 5;
        }
        else if ((r = java.util.concurrent.ThreadLocalRandom.current().nextInt()) == 0)
            r = 1; // avoid zero
        UNSAFE.putInt(t, SECONDARY, r);
        return r;
    }

    /**
     * /**
     *  * 三种情况停止阻塞：
     *  * 1. 调用unpark
     *  * 2. 线程被中断
     *  * 3. 设置时间到了
     *  * @Param isAbsolute 是否绝对时间
     *  * @Param time 时间 为0时代表无线等待
     *  *
     * Unsafe.park(boolean isAbsolute,long time);
     *
     * /**
     *  * 释放某线程，需要保证释放时线程存活
     *  *
     * Unsafe.unpark(Thread thread);
     */
    private static final sun.misc.Unsafe UNSAFE;
    /**
     * 获取每个字段的偏移地址
     */
    private static final long parkBlockerOffset;
    private static final long SEED;
    private static final long PROBE;
    private static final long SECONDARY;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            parkBlockerOffset = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("parkBlocker"));
            SEED = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomSeed"));
            PROBE = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomProbe"));
            SECONDARY = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
        } catch (Exception ex) { throw new Error(ex); }
    }

}