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()");
     }