Java - LockSupport 源码阅读笔记

in TCEH Java

简介

  用于创建锁和其他同步类的基本线程阻塞原语。其中两个比较重要的方法:park()方法用于阻塞线程;unpark(Thread thread)方法用于唤醒线程。优先调用unpark(Thread thread)方法相当于给指定线程颁发了一张许可,后续调用park()方法不会被阻塞。且其具体实现还是依托于Unsafe类。

LockSupport 类

public class LockSupport {
    private LockSupport() {} // 不能被实例化.均以静态方式访问

    private static void setBlocker(Thread t, Object arg) {
        // 记录线程t被对象arg阻塞
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

    // 如果给定线程的许可尚不可用,则使其可用。
    // 如果线程在 park 上受阻塞,则它将解除其阻塞状态。
    // 否则,保证下一次调用 park 不会受阻塞。
    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);// 唤醒线程
    }

    // 为了线程调度,在许可可用之前阻塞当前线程。 
    // 如果许可可用,则使用该许可,并且立即返回;
    // 否则,为线程调度禁用当前线程,并在发生以下三种情况之一以前,使其处于休眠状态:
    //  1. 其他线程将当前线程作为目标调用 unpark
    //  2. 其他线程中断当前线程
    //  3. 虚拟调用
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }

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

    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        setBlocker(t, null);
    }

    // 获取阻塞对象
    public static Object getBlocker(Thread t) {
        if (t == null)
            throw new NullPointerException();
        return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
    }
    // 为了线程调度,在许可可用之前阻塞当前线程。 
    // 如果许可可用,则使用该许可,并且立即返回;
    // 否则,为线程调度禁用当前线程,并在发生以下三种情况之一以前,使其处于休眠状态:
    //  1. 其他线程将当前线程作为目标调用 unpark
    //  2. 其他线程中断当前线程
    //  3. 虚拟调用
    public static void park() {
        UNSAFE.park(false, 0L);
    }

    // 附带相对超时版的park
    public static void parkNanos(long nanos) {
        if (nanos > 0)
            UNSAFE.park(false, nanos);
    }

    // 附带绝对超时版的park
    public static void parkUntil(long deadline) {
        UNSAFE.park(true, deadline);
    }

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

    // Hotspot implementation via intrinsics API
    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); }
    }

}