AQS 框架之 LockSupport 线程阻塞工具类

■ 前言

　　并发包一直是 JDK 里面比较难理解的，同时也是很精美的语言，膜拜下 Doug Li 大神。作者不敢长篇大论，只求循序渐进地把并发包通过理论和实战 (代码) 的方式介绍给大家。

其实做每一件事都是挺难的，不过只要下笔就不会瞻前顾后。谢谢大家的鼓励帮助，感谢我的好基友KIRA~  好的，热身先从 LockSupport 开始吧~

■ LockSupport 综述

• 定义： LockSupport 是一个线程阻塞工具类，可用于在线程内任意位置让线程阻塞和释放
• 作用： LockSupport 通常不会被直接使用，更多是作为锁实现的基础工具类
• 实现： LockSupport 底层依赖UnSafe实现，即 park() 和 unpark() 原语方法，通过"许可"替代状态
• 使用： park方法用于线程等待"许可"，unpark方法用于为线程提供"许可"
• 补充1：由于"许可"的存在，当出现一个线程调用park方法，其他线程调用unpark方法时，会保持活跃
• 补充2：若开JVM篇的话笔者会从JVM源码角度再次解析park和unpark的底层实现，其实质用mutex和condition维护一个_counter(park->0，unpark->1)的变量，即"许可"是一次性的
• 补充3：此番为 AQS 框架之综述 (赶制中) 的子番

■ LockSupport 数据结构

　1. 类定义

public class LockSupport 

　

2. 构造器

//私有构造器，不能被实例化 -- 实质就是个工作类，只能调用静态方法
private LockSupport() {} // Cannot be instantiated.

3. UnSafe

// Hotspot implementation via intrinsics API
private static final sun.misc.Unsafe UNSAFE;
//用于记录线程被谁阻塞的，用于线程监控和分析工具来定位原因，其表示parkBlocker在内存的偏移量
//之所以用偏移量是因为parkBlockerOffset被赋值时线程必须是阻塞的，阻塞时直接调方法无效只能走内存
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); }
}

■ Unsafe 综述

• 作用： Unsafe是个后门类，封装了一些类似指针的操作，提供了一些可以直接操控内存和线程的底层操作
• 使用： Unsafe被JDK广泛用于nio包和并发包中，但是不建议在生产环境使用，风险太大
• 不安全： 不安全指的是指针的操作不安全(Java因此才把指针去掉)，若指针指错位置或计算指针偏移量出错，结果不可想象，比如说覆盖了别人的内存，那可能就GG思密达了...
• 补充1： 有机会开JVM番的话，笔者会从JVM源码角度重新解析Unsafe一些重要方法的实现
• 补充2： 此番为 AQS 框架之综述 (赶制中) 的子番

■ Unsafe 数据结构

　1. 类定义

public final class Unsafe

2. 构造器

//私有构造器 --单例模式
private Unsafe() {}

3. 重要变量

private static final Unsafe theUnsafe;
public static final int INVALID_FIELD_OFFSET = -1;
public static final int ARRAY_BOOLEAN_BASE_OFFSET;
public static final int ARRAY_BYTE_BASE_OFFSET;
public static final int ARRAY_SHORT_BASE_OFFSET;
public static final int ARRAY_CHAR_BASE_OFFSET;
public static final int ARRAY_INT_BASE_OFFSET;
public static final int ARRAY_LONG_BASE_OFFSET;
public static final int ARRAY_FLOAT_BASE_OFFSET;
public static final int ARRAY_DOUBLE_BASE_OFFSET;
public static final int ARRAY_OBJECT_BASE_OFFSET;
public static final int ARRAY_BOOLEAN_INDEX_SCALE;
public static final int ARRAY_BYTE_INDEX_SCALE;
public static final int ARRAY_SHORT_INDEX_SCALE;
public static final int ARRAY_CHAR_INDEX_SCALE;
public static final int ARRAY_INT_INDEX_SCALE;
public static final int ARRAY_LONG_INDEX_SCALE;
public static final int ARRAY_FLOAT_INDEX_SCALE;
public static final int ARRAY_DOUBLE_INDEX_SCALE;
public static final int ARRAY_OBJECT_INDEX_SCALE;
public static final int ADDRESS_SIZE;
private static native void registerNatives();
static {
    registerNatives();
    Reflection.registerMethodsToFilter(Unsafe.class, new String[]{"getUnsafe"});
    theUnsafe = new Unsafe();//单例模式 -饿汉式
    ARRAY_BOOLEAN_BASE_OFFSET = theUnsafe.arrayBaseOffset(boolean[].class);
    ARRAY_BYTE_BASE_OFFSET = theUnsafe.arrayBaseOffset(byte[].class);
    ARRAY_SHORT_BASE_OFFSET = theUnsafe.arrayBaseOffset(short[].class);
    ARRAY_CHAR_BASE_OFFSET = theUnsafe.arrayBaseOffset(char[].class);
    ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset(int[].class);
    ARRAY_LONG_BASE_OFFSET = theUnsafe.arrayBaseOffset(long[].class);
    ARRAY_FLOAT_BASE_OFFSET = theUnsafe.arrayBaseOffset(float[].class);
    ARRAY_DOUBLE_BASE_OFFSET = theUnsafe.arrayBaseOffset(double[].class);
    ARRAY_OBJECT_BASE_OFFSET = theUnsafe.arrayBaseOffset(Object[].class);
    ARRAY_BOOLEAN_INDEX_SCALE = theUnsafe.arrayIndexScale(boolean[].class);
    ARRAY_BYTE_INDEX_SCALE = theUnsafe.arrayIndexScale(byte[].class);
    ARRAY_SHORT_INDEX_SCALE = theUnsafe.arrayIndexScale(short[].class);
    ARRAY_CHAR_INDEX_SCALE = theUnsafe.arrayIndexScale(char[].class);
    ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale(int[].class);
    ARRAY_LONG_INDEX_SCALE = theUnsafe.arrayIndexScale(long[].class);
    ARRAY_FLOAT_INDEX_SCALE = theUnsafe.arrayIndexScale(float[].class);
    ARRAY_DOUBLE_INDEX_SCALE = theUnsafe.arrayIndexScale(double[].class);
    ARRAY_OBJECT_INDEX_SCALE = theUnsafe.arrayIndexScale(Object[].class);
    ADDRESS_SIZE = theUnsafe.addressSize();
}

4. 重要方法

//获得给定对象内存偏移量的int值
public native int getInt(Object var1, long var2);
//设置给定对象内存偏移量的int值
public native void putInt(Object var1, long var2, int var4);
public native Object getObject(Object var1, long var2);
public native void putObject(Object var1, long var2, Object var4);
//....还有Boolean、Byte、Char、Short、Long、Float、Double的get\set....
//内存分配、释放
//分配内存
public native long allocateMemory(long var1);
//扩充内存
public native long reallocateMemory(long var1, long var3);
public native void setMemory(Object var1, long var2, long var4, byte var6);
public void setMemory(long var1, long var3, byte var5) {
    this.setMemory((Object)null, var1, var3, var5);
}
//拷贝内存
public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7);
public void copyMemory(long var1, long var3, long var5) {
    this.copyMemory((Object)null, var1, (Object)null, var3, var5);
}
//释放内存
public native void freeMemory(long var1);
//获取字段在对象中的内存偏移量
public native long staticFieldOffset(Field var1);
public native long objectFieldOffset(Field var1);
public native Object staticFieldBase(Field var1);
public native void ensureClassInitialized(Class<?> var1);
//数组元素定位
//arrayBaseOffset 和 arrayIndexScale 搭配使用可以定位数组中每个元素在内存中的位置
//获取数组第一个元素的偏移地址
public native int arrayBaseOffset(Class<?> var1);
//获取数组的转换因子，也就是数组中元素的增量地址
public native int arrayIndexScale(Class<?> var1);
public native int addressSize();
public native int pageSize();
//类定义
public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4, ClassLoader var5, ProtectionDomain var6);
public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4);
public native Class<?> defineAnonymousClass(Class<?> var1, byte[] var2, Object[] var3);
//创建实例
public native Object allocateInstance(Class<?> var1) throws InstantiationException;
//Synchronized同步块的指令实现 1.8版的全部是@Deprecated
public native void monitorEnter(Object var1);
public native void monitorExit(Object var1);
public native boolean tryMonitorEnter(Object var1);
//异常抛出
public native void throwException(Throwable var1);
//CAS操作
/**
* 比较obj的offset处内存位置中的值和期望的值，如果相同则更新，此更新是不可中断的
* @param obj 需要更新的对象
* @param offset obj中整型field的偏移量
* @param expect 希望field中存在的值
* @param update 如果期望值expect与field的当前值相同，设置filed的值为这个新值
* @return 如果field的值被更改返回true
*/
public final native boolean compareAndSwapObject(Object obj, long offset, Object expect, Object update);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
//获取给定对象的指定类型值，支持volatile load语义
public native Object getObjectVolatile(Object var1, long var2);
public native void putObjectVolatile(Object var1, long var2, Object var4);
public native int getIntVolatile(Object var1, long var2);
//设置给定对象的int值，支持volatile load语义
public native void putIntVolatile(Object var1, long var2, int var4);
//....还有Boolean、Byte、Char、Short、Long、Float、Double的volatile级别的get\put....
public native void putDoubleVolatile(Object var1, long var2, double var4);
public native void putOrderedObject(Object var1, long var2, Object var4);
public native void putOrderedInt(Object var1, long var2, int var4);
public native void putOrderedLong(Object var1, long var2, long var4);
//LockSupport类的原语支持-挂起和唤醒某个线程
public native void unpark(Object var1);
public native void park(boolean var1, long var2);
public native int getLoadAverage(double[] var1, int var2);
//提供线程安全的add和set操作
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}
public final int getAndSetInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var4));
    return var5;
}
//...还有Long和Object的线程安全的add和set操作...
//栅栏支持
public native void loadFence();
public native void storeFence();
public native void fullFence();

5. 禁用的工厂方法

@CallerSensitive
public static Unsafe getUnsafe() {
    Class var0 = Reflection.getCallerClass();
    //该方法用于判断调用者的类加载器是否是系统核心加载器（即Bootstrap加载器）
    if(!VM.isSystemDomainLoader(var0.getClassLoader())) {
        throw new SecurityException("Unsafe");
    } else {
        return theUnsafe;
    }
}

• 我们先显性调用该工厂方法查看一下调用结果

package concurrent;
import sun.misc.Unsafe;
public class UnsafeDemo {
    public static void main(String[] args) {
        Unsafe.getUnsafe();
    }
}
-------------------
//输出：
Exception in thread "main" java.lang.SecurityException: Unsafe
    at sun.misc.Unsafe.getUnsafe(Unsafe.java:90)
    at concurrent.UnsafeDemo.main(UnsafeDemo.java:7)
//分析：可以发现直接调用的话会直接抛出安全异常，原因是类加载器是AppClassLoader而并非是BootstrapLoader  

• 根据Java 类加载器的工作原理，应用程序的类由AppLoader加载，而系统核心类由BootstrapLoader加载
• 当一个类的类加载器为null时，说明它是由BootstrapLoader加载的，即此类是系统核心类(比如rt.jar包中的类)
• 当一个类无法被BootstrapLoader加载时，其类加载器通常为AppClassLoader，即是属于自定义类

■ Unsafe 反射获取

/**
  * 我们可以通过反射机制获取Unsafe 的一个实例
  */
public static Unsafe getUnsafe(){
    try {
        //通过反射获取Unsafe的theUnsafe变量，即Unsafe实例对象
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        //注意field是static属性
        //参见：private static final Unsafe theUnsafe;
        return (Unsafe) f.get(null);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

4. permit (许可)

• LockSupport 和每个使用它的线程都与一个permit关联，某种意义上可认为是 Semaphore 类，但区别于Semaphores，permit至多只有一个，并不能被累加（即重复调动unpark也不会累加，最多为1）
• permit 相当于一个开关(只有0和1两个值)，默认为0，执行过程如下：
  • 调用unpark方法，permit+1，即permit=1
  • 调用park方法，permit被消费-1，即permit=0，同时park方法理解返回
  • 再次调用park方法，线程会被阻塞(此时permit=0，线程无许可可用，直到permit=1之前都会被阻塞)

■ LockSupport 数据结构

　1. setBlocker / getBlocker

 /**
  * Returns the blocker object supplied to the most recent
  * invocation of a park method that has not yet unblocked, or null
  * if not blocked.  The value returned is just a momentary
  * snapshot -- the thread may have since unblocked or blocked on a
  * different blocker object.
  *  返回提供给最近一次尚未解除阻塞的被park方法调用的blocker对象，如果该调用未阻塞，则返回null
  * @param t the thread
  * @return the blocker
  * @throws NullPointerException if argument is null
  * @since 1.6
  */
 public static Object getBlocker(Thread t) {
     if (t == null)
         throw new NullPointerException();
     return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
 }
 /**
   * This object is recorded while the thread is blocked to permit monitoring and diagnostic
   * tools to identify the reasons that threads are blocked.
   * 此对象在线程受阻塞时被记录，以允许监视工具和诊断工具确定线程受阻塞的原因
   */
 private static void setBlocker(Thread t, Object arg) {
     // Even though volatile, hotspot doesn't need a write barrier here.
     UNSAFE.putObject(t, parkBlockerOffset, arg);
 }

• 通过线程 Dump 查看一下，可以很明显的看到阻塞的堆栈信息，但其实信息是差不多一样的

· 2. park

• 作用：该方法用于等待"许可"，调用时可能发生以下两种情况：
  • 当"许可"可用时，立即返回并且消费这个许可(将许可变成不可用)
  • 当"许可"不可用时，当前线程可能被阻塞 java.lang.Thread.State : WAITING parking
• 使用： 由于park方法可能在任何时候"无理由"返回，因此通常会在循环中使用(在返回之前再次检查条件)
• 适用： park方法是"busy wait"(忙碌等待)的一种优化 (即不需要在自旋上浪费太多时间)，但它必须与 unpark 配对使用才更高效
• 注意： park方法的许可默认是被占用的，在unpark之前调用会获取不到许可而被阻塞

public static void park() {
    UNSAFE.park(false, 0L);
}
//纳秒级超时返回
public static void parkNanos(long nanos) {
    if (nanos > 0)
        UNSAFE.park(false, nanos);
}
//毫秒级限时等待
//注意这里的时间需要使用系统时间加上需要等待的时间
//LockSupport.parkUntil(System.currentTimeMillis() + 3000);
public static void parkUntil(long deadline) {
    UNSAFE.park(true, deadline);
}
//三种形式的 park 还各自支持一个 blocker 对象参数
//建议最好使用这些形式，而不是不带此参数的原始形式
//在锁实现中提供的作为 blocker 的普通参数是 this
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);
}

· 3. unpark

• 作用： 该方法用于提供"许可"，会将还不可用的"许可"变成可用
• 注意： 由于 park方法默认是许可占有并阻塞线程，因此调用 park之前最好先调用 unpark (当然因为 park\unpark 的顺序解耦性，所以前后执行顺序无所谓，只是代码上最好遵循 先释放再获取 的规则)

/**
  * 注意：必须指定一个线程(但无所谓该线程是否park)，将尝试释放其可能拥有的许可
  */
public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread);
}

· 4. LockSupport 不可重入

• 不可重入： LockSupport 不可重入，当一个线程多次调用 park 方法，线程将被第二个 park 方法阻塞

 public static void main(String[] args) {
     LockSupport.unpark(Thread.currentThread());//我们直接用主线程
     System.out.println("执行unpark");
     LockSupport.park();
     System.out.println("执行第一次park");
     LockSupport.park();
     System.out.println("执行第二次park");
     while (true);
 }
 ---------------------
 //输出：
 执行unpark
 执行第一次park
 //分析：通过打印结果可以发现第7行其实并没有被打印，根据下面的图片可以看到线程在第7行(对应图片的第16行)上阻塞

• 使用 jstack 命令查看一下线程状态，会发现线程是 WAITING 状态，即等待阻塞，而且还是被 park方法阻塞

·5. LockSupport 与中断

• 中断响应： LockSupport支持中断响应，线程调用park阻塞时仍能够响应中断请求，但不会抛出InterruptedException异常

public static void main(String[] args) {
    Thread thread = new Thread(() -> {
        long start = System.currentTimeMillis();
        while ((System.currentTimeMillis() - start) <= 1000);//空转1s
        System.out.println("空转1s结束");
        LockSupport.park();//等待"许可"
        System.out.println(Thread.currentThread().getName() + "是否被中断："
            + Thread.currentThread().isInterrupted());
    },"kira");
    thread.start();
    thread.interrupt();//中断线程
}
---------------------
//输出：
空转1s结束
kira是否被中断：true
//分析：通过先中断线程再park可以发现可获取中断响应，同时并没有抛出任何异常

■ suspend()  VS  wait()  VS  park()

　 1. suspend() VS wait()

• suspend() 不会释放锁，wait()会释放锁同时还支持超时处理

2. suspend() VS wait()

• LockSupport 解决了suspend()不释放锁从而容易死锁的问题，比如resume()方法被阻塞时，即其他线程在调用 resume()方法之前获取同步锁时被阻塞而导致 resume()方法无法执行进而导致死锁

3. park() VS wait()

• LockSupport 不需要先获得某个对象的锁，也不会排除 InterruptedException异常
• unpark 方法可以先于park方法调用，其没有方法调用的时序问题
• wait/notify 机制有个问题在于线程调用notify方法去唤醒其他线程时，需要保证需被唤醒线程必须被wait方法阻塞，否则被唤醒线程会永远处于 WAITING 状态，同时notify方法只能唤醒一个线程，当同时有多个线程在同一个对象上 wait 等待，就只能有一个线程可以被唤醒(不能指定)
• park/unpark 机制通过引入单个"许可"的概念实现对线程同步的解耦，线程间无须关心对方的状态，因为不需要一个变量专门用于存储状态