LockSupport源码解析

一、前言

    LockSupport 和 CAS 是Java并发包中很多并发工具控制机制的基础，它们底层其实都是依赖Unsafe实现。

    LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。LockSupport 提供park()和unpark()方法实现阻塞 线程和解除线程阻塞，LockSupport和每个使用它的线程都与一个许可(permit)关联。permit相当于1，0的开 关，默认是0，调用一次unpark就加1变成1，调用一次park会消费permit, 也就是将1变成0，同时park立即返 回。再次调用park会变成block（因为permit为0了，会阻塞在这里，直到permit变为1）, 这时调用unpark会把 permit置为1。每个线程都有一个相关的permit, permit最多只有一个，重复调用unpark也不会积累。

二、使用LockSupport的park和unpark来实现同步

代码实例

package homework;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

/**
 * @Author czd
 * @Date:createed in
 * @Version: V1.0
 */
public class LockSupportDemo {
    static class MyThread extends Thread{
        private Object object;

        public MyThread(Object o){
            this.object = o;
        }

        @Override
        public void run() {
            //主要是对object执行unpark
            System.out.println("before unpark");
            try {
                TimeUnit.SECONDS.sleep(1);
            }catch (Exception e){
                e.printStackTrace();
            }

            //获取当前blocker
            System.out.println("BlockInfo:" + LockSupport.getBlocker((Thread)this.object));
            LockSupport.unpark((Thread)this.object);

            try {
                TimeUnit.SECONDS.sleep(1);
            }catch (Exception e){
                e.printStackTrace();
            }
            //再次获取当前blocker
            System.out.println("BlockInfo:" + LockSupport.getBlocker((Thread)this.object));
            System.out.println("after unpark");
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread(Thread.currentThread());
        myThread.start();
        System.out.println("before park");
        LockSupport.park("LockSupportDemo");
        System.out.println("after park");
    }
}

运行结果

三、源码解析

继承了哪些类

    由上图可知LockSupport类是没有父类以及实现任何接口的，孑然一身的。

变量说明

// Hotspot implementation via intrinsics API
//unsafe常量，设置为使用Unsafe.compareAndSwapInt进行更新
//UNSAFE字段表示sun.misc.Unsafe类，一般程序中不允许直接调用
private static final sun.misc.Unsafe UNSAFE;
//表示parkBlocker在内存地址的偏移量
private static final long parkBlockerOffset;
//表示threadLocalRandomSeed在内存地址的偏移量，此变量的作用暂时还不了解
private static final long SEED;
//表示threadLocalRandomProbe在内存地址的偏移量，此变量的作用暂时还不了解
private static final long PROBE;
//表示threadLocalRandomSecondarySeed在内存地址的偏移量
// 作用是 可以通过nextSecondarySeed()方法来获取随机数
private static final long SECONDARY;

变量是如何获取其实例对象的？

static {
   try {
        //实例化unsafe对象
        UNSAFE = sun.misc.Unsafe.getUnsafe();
        Class<?> tk = Thread.class;
        //利用unsafe对象来获取parkBlocker在内存地址的偏移量
        parkBlockerOffset = UNSAFE.objectFieldOffset(tk.getDeclaredField("parkBlocker"));
        //利用unsafe对象来获取threadLocalRandomSeed在内存地址的偏移量
        SEED = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomSeed"));
        //利用unsafe对象来获取threadLocalRandomProbe在内存地址的偏移量
        PROBE = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomProbe"));
        //利用unsafe对象来获取threadLocalRandomSecondarySeed在内存地址的偏移量
        SECONDARY = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomSecondarySeed"));
    } catch (Exception ex) { throw new Error(ex); }
}

    由上面代码可知这些变量是通过static代码块在类加载的时候就通过unsafe对象获取其在内存地址的偏移量了。

构造方法

//LockSupport只有一个私有构造函数，无法被实例化。
private LockSupport() {} // Cannot be instantiated.

两个特殊的方法

//设置线程t的parkBlocker字段的值为arg
private static void setBlocker(Thread t, Object arg) {
    // Even though volatile, hotspot doesn't need a write barrier here.
    //尽管hotspot易变，但在这里并不需要写屏障。
    UNSAFE.putObject(t, parkBlockerOffset, arg);
}

//获取当前线程的Blocker值
public static Object getBlocker(Thread t) {
    //若当前线程为空就抛出异常
    if (t == null)
        throw new NullPointerException();
    //利用unsafe对象获取当前线程的Blocker值
    return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
}

常用方法

① unpark(Thread thread)方法。

//释放该线程的阻塞状态，即类似释放锁，只不过这里是将许可设置为1
public static void unpark(Thread thread) {
    //判断线程是否为空
    if (thread != null)
        //释放该线程许可
        UNSAFE.unpark(thread);
}

② park(Object blocker)方法 和 park()方法。

//阻塞当前线程，并且将当前线程的parkBlocker字段设置为blocker
public static void park(Object blocker) {
    //获取当前线程
    Thread t = Thread.currentThread();
    //将当前线程的parkBlocker字段设置为blocker
    setBlocker(t, blocker);
    //阻塞当前线程，第一个参数表示isAbsolute，是否为绝对时间，第二个参数就是代表时间
    UNSAFE.park(false, 0L);
    //重新可运行后再此设置Blocker
    setBlocker(t, null);
}
    
//无限阻塞线程，直到有其他线程调用unpark方法
public static void park() {
    UNSAFE.park(false, 0L);
}

说明：调用park函数时，首先获取当前线程，然后设置当前线程的parkBlocker字段，即调用setBlocker函数， 之后调用Unsafe类的park函数，之后再调用setBlocker函数。那么问题来了，**为什么要在此park函数中要调用两次setBlocker函数呢？**原因其实很简单，调用park函数时，当前线程首先设置好parkBlocker字段，然后再调用 Unsafe的park函数，此后，当前线程就已经阻塞了，等待该线程的unpark函数被调用，所以后面的一个 setBlocker函数无法运行，unpark函数被调用，该线程获得许可后，就可以继续运行了，也就运行第二个 setBlocker，把该线程的parkBlocker字段设置为null，这样就完成了整个park函数的逻辑。如果没有第二个 setBlocker，那么之后没有调用park(Object blocker)，而直接调用getBlocker函数，得到的还是前一个 park(Object blocker)设置的blocker，显然是不符合逻辑的。总之，必须要保证在park(Object blocker)整个函数 执行完后，该线程的parkBlocker字段又恢复为null。所以，park(Object)型函数里必须要调用setBlocker函数两次。

③ parkNanos(Object blocker, long nanos)方法 和 parkNanos(long nanos)方法。

//阻塞当前线程nanos秒
public static void parkNanos(Object blocker, long nanos) {
    //先判断nanos是否大于0，小于等于0都代表无限等待
    if (nanos > 0) {
        //获取当前线程
        Thread t = Thread.currentThread();
        //将当前线程的parkBlocker字段设置为blocker
        setBlocker(t, blocker);
        //阻塞当前线程现对时间的nanos秒
        UNSAFE.park(false, nanos);
        //将当前线程的parkBlocker字段设置为null
        setBlocker(t, null);
    }
}

//阻塞当前线程nanos秒，现对时间
public static void parkNanos(long nanos) {
    if (nanos > 0)
        UNSAFE.park(false, nanos);
}

④ parkUntil(Object blocker, long deadline)方法 和 parkUntil(long deadline)方法。

//将当前线程阻塞绝对时间的deadline秒，并且将当前线程的parkBlockerOffset设置为blocker
public static void parkUntil(Object blocker, long deadline) {
    //获取当前线程
    Thread t = Thread.currentThread();
    //设置当前线程parkBlocker字段设置为blocker
    setBlocker(t, blocker);
    //阻塞当前线程绝对时间的deadline秒
    UNSAFE.park(true, deadline);
    //当前线程parkBlocker字段设置为null
    setBlocker(t, null);
}

//将当前线程阻塞绝对时间的deadline秒
public static void parkUntil(long deadline) {
    UNSAFE.park(true, deadline);
}

四、总结

    LockSupport 和 CAS 是Java并发包中很多并发工具控制机制的基础，它们底层其实都是依赖Unsafe实现。很多锁的类都是基于LockSupport的park和unpark来实现的。所以了解LockSupport类是非常重要的，不过我还是有一些疑问？就是变量SEED和PROBE的作用是什么？