1.簡介

LockSupport類可以阻塞當前線程和喚醒指定被阻塞的線程，主要通過park,和unpark(thread)方法來實現(xiàn)阻塞和喚醒線程的操作。
1.當調(diào)用unpark(thread)方法，就會將thread線程的許可permit設(shè)置為(多次調(diào)用unpark方法，不會累加，permit值還是1)。
2.當調(diào)用park()方法時，如果當前線程的permit是1，那么將permit的值設(shè)置為0，并立即返回。如果當前線程的permit是0，那么當前線程就會阻塞，知道別的線程把當前線程的permit值設(shè)置為1，然后park方法再將它設(shè)置為0，并返回。

2.源碼解析

package java.util.concurrent.locks;
import sun.misc.Unsafe;

import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadLocalRandom;

/**
 * 提供阻塞線程和喚醒線程的方法。
 */
public class LockSupport {
    // 構(gòu)造函數(shù)是私有的，所以不能在外部實例化
    private LockSupport() {}

    // 用來設(shè)置線程t的parkBlocker屬性。此對象在線程受阻塞時被記錄，以允許監(jiān)視工具和診斷工具確定線程受阻塞的原因。
    private static void setBlocker(Thread t, Object arg) {
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

    // 喚醒處于阻塞狀態(tài)下的thread線程
    public static void unpark(Thread thread) {
        // 當線程不為null時調(diào)用
        if (thread != null)
            // 通過UNSAFE的unpark喚醒被阻塞的線程
            UNSAFE.unpark(thread);
    }

    // 阻塞當前線程
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        // 設(shè)置線程t的parkBlocker屬性，用于記錄線程阻塞情況
        setBlocker(t, blocker);
        // 通過UNSAFE的park方法阻塞線程
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }

    // 阻塞當前線程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);
        }
    }
    // 阻塞當前線程，超過deadline日期線程就會被喚醒返回
    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        setBlocker(t, null);
    }

    // 獲取線程t的parkBlocker屬性
    public static Object getBlocker(Thread t) {
        if (t == null)
            throw new NullPointerException();
        return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
    }

    // 阻塞當前線程，不設(shè)置parkBlocker屬性
    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);
    }

    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 = ThreadLocalRandom.current().nextInt()) == 0)
            r = 1; // avoid zero
        UNSAFE.putInt(t, SECONDARY, r);
        return r;
    }

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

}

3總結(jié)

1.歸根到底，LockSupport調(diào)用Unsafe中的native代碼

public native void unpark(Thread jthread); 
public native void park(boolean isAbsolute, long time); 

2.關(guān)于許可
unpark()放在park之前也可以實現(xiàn)同步，也就是說先提供許可，在操作也是可行的?？梢灶惐鹊缴a(chǎn)者消費者模型理解，先提供許可，然后使用許可。這是他優(yōu)與wait/notify的地方。