本文共 5462 字，大约阅读时间需要 18 分钟。

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的法外之地。

彩蛋

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

感谢关注

转载地址：https://keepgoon.blog.csdn.net/article/details/116243732 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！