这个类比较简单，是一个静态类，不需要实例化直接使用，底层是通过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 }