大话JUC核心类LockSupport（通过源码理解LockSupport）

---

LockSupport简介

LockSupport是创建锁和其他同步类的基本线程阻塞原语。它的方法都是静态方法，可以让线程在任意位置阻塞，也可以在任意位置唤醒。

简而言之，当调用LockSupport.park时，表示当前线程将会等待，直至获得许可，当调用LockSupport.unpark时，必须把等待获得许可的线程作为参数进行传递，好让此线程继续运行。

LockSupport源码分析

删除了官方注释

package java.util.concurrent.locks;
// java 实现线程安全非常重要的对象
import sun.misc.Unsafe;

public class LockSupport {
     
	// 不能被实例化（它所有的方法都是静态的）
    private LockSupport() {
     } 

    private static void setBlocker(Thread t, Object arg) {
     
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

    public static void unpark(Thread thread) {
     
        if (thread != null)
            UNSAFE.unpark(thread);
    }
    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);
    }

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

}

1.私有化的构造函数

 private LockSupport() {
     } 

LockSupport 的构造函数是私有化的，因此不能被实例化。它的所有方法都是静态的，因此也不需要进行实例化。

2.LockSupport的属性

private static final sun.misc.Unsafe UNSAFE;

Unsafe 对象

private static final long parkBlockerOffset;

表示parkBlocker在内存地址的偏移量

private static final long SEED;

表示threadLocalRandomSeed在内存地址的偏移量

 private static final long PROBE;

表示threadLocalRandomProbe在内存地址的偏移量

private static final long SECONDARY;

表示threadLocalRandomSecondarySeed在内存地址的偏移量

3.静态代码块

UNSAFE = sun.misc.Unsafe.getUnsafe(); 

首先获取Unsafe实例，Unsafe实例是java线程安全的非常重要的实现核心，我们常用的Atomic类就是有Unsafe实现。

---

parkBlockerOffset = UNSAFE.objectFieldOffset(tk.getDeclaredField("parkBlocker"));

获取Thread的parkBlocker字段的内存偏移地址

一般程序中不允许直接调用Unsafe，而long型的表示实例对象相应字段在内存中的偏移地址，可以通过该偏移地址获取或者设置该字段的值

4.park核心函数

源码：

    public static void park(Object blocker) {
     
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }

park函数用来阻塞线程。如果许可可用，会立马返回，并消费掉许可。该线程在下列情况发生之前都会被阻塞:

1. 调用unpark函数，释放该线程的许可。
2. 该线程被中断。
3. 设置的等待时间到了。

可以看出实际上 ：park调用了Unsafe实例的park方法，并且传入的等待时间为0。等待时间为0表示永久等待，直达遇到 unpark。

为让用户自动结束等待，LockSupport类有另一个静态的实现parkUntil :

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

首先获取当前线程，然后设置阻塞块为，当前对象，然后锁定当前线程，然后将线程锁定块设置为null。

注意：为什么执行了两次setBlocker呢 ？

1. 第一次执行setBlocker设置当前对象阻塞。然后执行了park函数获取许可。
2. 当执行了unPark或者等待时间到期执行第二个setBlocker。
3. 第二个setBlocker将线程设置许可。

许可可以理解为锁。获取许可可以认为是加锁，unPark 释放许可可以认为是释放锁。

4.unpark核心函数

    public static void unpark(Thread thread) {
     
    	// 如果线程不是空，就释放线程许可（解锁）
        if (thread != null)
            UNSAFE.unpark(thread);
    }

unpark函数是获取线程许可，如果线程不是空，就释放线程许可，让线程可以继续执行。

Thread.sleep()和LockSupport.park()

对于我们常用的多线程编程设置线程等待大部分都是直接调用Thread.sleep()。那么同样是线程等待 Thread.sleep()和LockSupport.park()有什么区别呢？

1. 从功能上来说，Thread.sleep()和LockSupport.park()方法类似，都是阻塞当前线程的执行，且都不会释放当前线程占有的锁资源；
2. Thread.sleep()没法从外部唤醒，只能自己醒过来；
3. LockSupport.park()方法可以被另一个线程调用LockSupport.unpark()方法唤醒；
4. Thread.sleep()方法声明上抛出了InterruptedException中断异常，所以调用者需要捕获这个异常或者再抛出;
5. LockSupport.park()方法不需要捕获中断异常； Thread.sleep()本身就是一个native方法；
6. LockSupport.park()底层是调用的Unsafe的native方法；

注意

LockSupport.park()不会自动释放资源。Unsafe这个类锁定的资源不会被JVM管理，Unsafe的方式都是native，你懂得，这个直接内存，JVM的法外之地。

彩蛋

超神学院语录:

不被天使迷惑是不可能的，她们几乎零缺点，她不断的让我感受到她的美丽，甚至有些善良，也不断的念叨着正义，然而危机临近我却不以为然。

感谢关注

正在路上的架构师