LockSupport

对线程阻塞/唤醒可以用Object的wait/notify，LockSupport是另一种对线程阻塞/唤醒的原语，由park/unpark对应且基于Unsafe实现。 Condition和Lock均基于此类实现。

LockSupport是一个工具类，所有方法均为static，构造方法为私有的。

域及静态块

// Unsafe实例
private static final sun.misc.Unsafe UNSAFE;
// Thread的parkBlocker字段偏移量
// 用于记录线程被谁阻塞
private static final long parkBlockerOffset;
// Thread的threadLocalRandomSeed字段偏移量
// 随机数生成种子
private static final long SEED;
// Thread的threadLocalRandomProbe字段偏移量
// 随机数
private static final long PROBE;
// Thread的threadLocalRandomSecondarySeed字段偏移量
// 随机数生成第二种子
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); }
}

方法

void setBlocker(Thread t, Object arg)

// 设置导致线程阻塞的对象
private static void setBlocker(Thread t, Object arg) {
    // Thread的parkBlocker字段为volatile
    // 所以不需要使用内存屏障
    UNSAFE.putObject(t, parkBlockerOffset, arg);
}

void unpark(Thread thread)

// 当给定线程许可不可用时，使得给定线程的许可可用
// 若当前线程阻塞(通过park方法)，则唤醒该线程
// 若线程没有start，则此方法没有任何效果
public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread);
}

void park(Object blocker)

// 阻塞当前线程除非当前线程许可可用
// 许可不可用时会阻塞直到：
// 1. unpark方法调用
// 2. 当前线程被中断
// 3. 调用没有原因返回
public static void park(Object blocker) {
    Thread t = Thread.currentThread();
    // 设置导致线程阻塞对象
    setBlocker(t, blocker);
    // 阻塞直到许可可用
    UNSAFE.park(false, 0L);
    // 设置导致线程阻塞对象为null
    setBlocker(t, null);
}

void parkNanos(Object blocker, long nanos)

// 阻塞给定纳秒
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);
    }
}

void parkUntil(Object blocker, long deadline)

// 阻塞到给定日期
public static void parkUntil(Object blocker, long deadline) {
    Thread t = Thread.currentThread();
    setBlocker(t, blocker);
    // 当isAbsolute为true时，timeout是相对于新纪元之后的毫秒
    // 具体见Unsafe
    UNSAFE.park(true, deadline);
    setBlocker(t, null);
}

void park()

// 阻塞当前线程 不保存导致线程阻塞的对象
public static void park() {
    UNSAFE.park(false, 0L);
}

void parkNanos(long nanos)

// 阻塞当前线程给定纳秒 不保存导致线程阻塞的对象
public static void parkNanos(long nanos) {
    if (nanos > 0)
        UNSAFE.park(false, nanos);
}

void parkUntil(long deadline)

// 阻塞到给定日期 不保存导致线程阻塞的对象
public static void parkUntil(long deadline) {
    UNSAFE.park(true, deadline);
}

Object getBlocker(Thread t)

// 获得最近导致线程阻塞的对象且该线程没被唤醒
public static Object getBlocker(Thread t) {
    if (t == null)
        throw new NullPointerException();
    return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
}

int nextSecondarySeed()

// xorshift算法获得下一个第二种子
// 用于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;
}