java之LockSupport的使用及源码

点击此处去Gitee上Clone源码下来在IDE上看效果更佳

package java.util.concurrent.locks;

/**
 * 用于创建锁和其他同步类的基本线程阻塞原语。
 */
public class LockSupport {
    private LockSupport() {
    } // 静态工具类，无法被实例化，硬是要用反射实例化那也没办法。

    /*常用的park与unpark方法*/

    /**
     * 为线程调度目的禁用当前线程，除非许可证可用。
     * <p>
     * 如果许可证可用，则它将被使用，并且调用立即返回；
     * 否则，当前线程将因线程调度而被禁用，并处于休眠状态，直到发生以下三种情况之一：
     * 另一个线程以当前线程为目标调用unpark；
     * 或者其他线程中断当前线程；
     * 或者错误地调用（也就是说，没有原因）返回。
     */
    public static void park() {
        UNSAFE.park(false, 0L);
    }


    /**
     * 1.传入线程是阻塞状态，则解除阻塞状态。
     * 2.传入线程是非阻塞状态，则下一次park的时候会立马解除阻塞，也就是unpark一次就有了张许可证，许可证无法叠加。
     */
    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }

    /**
     * 除了可以传入一个blocker外和park差不多
     * 可以通过getBlocker获取
     */
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }


    /**
     * 带时间的park，参数单位是毫秒
     */
    public static void parkUntil(long deadline) {
        UNSAFE.park(true, deadline);
    }

    /**
     * 带时间的park，参数单位是毫秒,可以传入blocker
     */
    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        setBlocker(t, null);
    }

    /**
     * 带时间的park，参数单位是纳秒
     */
    public static void parkNanos(long nanos) {
        if (nanos > 0)
            UNSAFE.park(false, nanos);
    }

    /**
     * 带时间的park，参数单位是纳秒,可以传入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);
        }
    }

    private static void setBlocker(Thread t, Object arg) {
        // Even though volatile, hotspot doesn't need a write barrier here.
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

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


    /**
     * Returns the pseudo-randomly initialized or updated secondary seed.
     * Copied from ThreadLocalRandom due to package access restrictions.
     */
    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);
        }
    }

}