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

彩蛋

大话JUC核心类LockSupport(通过源码理解LockSupport)
超神学院语录:

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

感谢关注

大话JUC核心类LockSupport(通过源码理解LockSupport)
正在路上的架构师

版权声明:玥玥 发表于 2021-04-30 13:24:12。
转载请注明:大话JUC核心类LockSupport(通过源码理解LockSupport) | 女黑客导航