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

 1 package java.util.concurrent.locks;  2 import java.util.concurrent.*;  3 import sun.misc.Unsafe;  4 
 5 
 6 public class LockSupport {  7     private LockSupport() {}  8 
 9     //这个类是java未开源的类，直接调用底层操作系统
10     private static final Unsafe unsafe = Unsafe.getUnsafe(); 11     //记录线程对象中parkBlocker字段的位置
12     private static final long parkBlockerOffset; 13 
14     static { 15         try { 16             parkBlockerOffset = unsafe.objectFieldOffset 17                 (java.lang.Thread.class.getDeclaredField("parkBlocker")); 18         } catch (Exception ex) { throw new Error(ex); } 19  } 20 
21     private static void setBlocker(Thread t, Object arg) { 22         // Even though volatile, hotspot doesn't need a write barrier here. 23         //将org设置到线程的parkBlocker字段上 24         //这样方便在测试的时候知道线程在什么地方阻塞
25  unsafe.putObject(t, parkBlockerOffset, arg); 26  } 27 
28     //调用底层操作系统解锁线程
29     public static void unpark(Thread thread) { 30         if (thread != null) 31  unsafe.unpark(thread); 32  } 33 
34     //设置blocker并且锁定线程
35     public static void park(Object blocker) { 36         Thread t = Thread.currentThread(); 37  setBlocker(t, blocker); 38         unsafe.park(false, 0L); 39         setBlocker(t, null); 40  } 41 
42     //设置blocker并且并且阻塞线程nanos纳秒 可以这么转换成毫秒 43     //TimeUnit timeUnit = TimeUnit.MILLISECONDS; 44     //LockSupport.parkNanos(timeUnit.toNanos(3000));
45     public static void parkNanos(Object blocker, long nanos) { 46         if (nanos > 0) { 47             Thread t = Thread.currentThread(); 48  setBlocker(t, blocker); 49             unsafe.park(false, nanos); 50             setBlocker(t, null); 51  } 52  } 53 
54     //设置blocker并且阻塞线程多少毫秒 55     //注意这里的时间需要使用系统时间加上需要等待的时间 56     //LockSupport.parkUntil(System.currentTimeMillis() + 3000);
57     public static void parkUntil(Object blocker, long deadline) { 58         Thread t = Thread.currentThread(); 59  setBlocker(t, blocker); 60         unsafe.park(true, deadline); 61         setBlocker(t, null); 62  } 63 
64     //获得线程阻塞时设置的Blocker
65     public static Object getBlocker(Thread t) { 66         if (t == null) 67             throw new NullPointerException(); 68         return unsafe.getObjectVolatile(t, parkBlockerOffset); 69  } 70 
71     //阻塞线程
72     public static void park() { 73         unsafe.park(false, 0L); 74  } 75 
76     public static void parkNanos(long nanos) { 77         if (nanos > 0) 78             unsafe.park(false, nanos); 79  } 80 
81     public static void parkUntil(long deadline) { 82         unsafe.park(true, deadline); 83  } 84 }

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

 1     public static void main(String[] args) {  2         
 3         final Thread mainThread = Thread.currentThread();  4         
 5         Thread thread = new Thread(new Runnable() {  6  @Override  7             public void run() {  8                 System.out.println("3秒后解锁主线程");  9                 try { 10                     Thread.sleep(3000); 11  LockSupport.unpark(mainThread); 12                 } catch (InterruptedException e) { 13  e.printStackTrace(); 14  } 15  } 16  }); 17  thread.start(); 18  LockSupport.park(); 19         
20         System.out.println("Demo.main()"); 21     }