Java并发编程 LockSupport源码分析

这个类比较简单，是一个静态类，不需要实例化直接使用，底层是通过java未开源的Unsafe直接调用底层操作系统来完成对线程的阻塞。

package java.util.concurrent.locks;
import java.util.concurrent.*;
import sun.misc.Unsafe;


public class LockSupport {
    private LockSupport() {}

    //这个类是java未开源的类，直接调用底层操作系统
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    //记录线程对象中parkBlocker字段的位置
    private static final long parkBlockerOffset;

    static {
        try {
            parkBlockerOffset = unsafe.objectFieldOffset
                (java.lang.Thread.class.getDeclaredField("parkBlocker"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private static void setBlocker(Thread t, Object arg) {
        // Even though volatile, hotspot doesn't need a write barrier here.
        //将org设置到线程的parkBlocker字段上
        //这样方便在测试的时候知道线程在什么地方阻塞
        unsafe.putObject(t, parkBlockerOffset, arg);
    }

    //调用底层操作系统解锁线程
    public static void unpark(Thread thread) {
        if (thread != null)
            unsafe.unpark(thread);
    }

    //设置blocker并且锁定线程
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        unsafe.park(false, 0L);
        setBlocker(t, null);
    }

    //设置blocker并且并且阻塞线程nanos纳秒 可以这么转换成毫秒
    //TimeUnit timeUnit = TimeUnit.MILLISECONDS;
    //LockSupport.parkNanos(timeUnit.toNanos(3000));
    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);
        }
    }

    //设置blocker并且阻塞线程多少毫秒
    //注意这里的时间需要使用系统时间加上需要等待的时间
    //LockSupport.parkUntil(System.currentTimeMillis() + 3000);
    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        unsafe.park(true, deadline);
        setBlocker(t, null);
    }

    //获得线程阻塞时设置的Blocker
    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);
    }
}

写一个简单DEMO，这个类使用起来也很简单，一般很少直接使用，java.util.concurrent包里有很多锁的实现都是基于此类，后续我们会讲到。

    public static void main(String[] args) {
        
        final Thread mainThread = Thread.currentThread();
        
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("3秒后解锁主线程");
                try {
                    Thread.sleep(3000);
                    LockSupport.unpark(mainThread);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        LockSupport.park();
        
        System.out.println("Demo.main()");
    }