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

曾经终败给现在 2023-01-17 09:30 128阅读 0赞

### LockSupport大纲 ###

*  LockSupport简介
 *   *  LockSupport源码分析
     *   *  1.私有化的构造函数
         *  2.LockSupport的属性
         *  3.静态代码块
         *  4.park核心函数
         *  4.unpark核心函数
     *  Thread.sleep()和LockSupport.park()
     *  注意
     *  彩蛋
     *  感谢关注

--------------------

# LockSupport简介 #

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

简而言之，当调用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的法外之地。

## 彩蛋 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NDYyNTY3_size_16_color_FFFFFF_t_70]  
**超神学院语录:**

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

## 感谢关注 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NDYyNTY3_size_16_color_FFFFFF_t_70 1]  
**正在路上的架构师**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NDYyNTY3_size_16_color_FFFFFF_t_70]: /images/20221021/d5f0618416bc4354ba34d1a34c4382b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NDYyNTY3_size_16_color_FFFFFF_t_70 1]: /images/20221021/c245aa1fbd9246c9a4435e2c1a46eeeb.png