教你如何使用Java多线程编程LockSupport工具类

LockSupport类

用于创建锁和其他同步类的基本线程阻塞原语，此类与使用它的每个线程关联一个许可。如果获得许可，将立即返回对park的调用，并在此过程中消耗掉它；否则may会被阻止。调用unpark可使许可证可用（如果尚不可用）。（不过与信号量不同，许可证不会累积。最多只能有一个。）
方法park和unpark提供了有效的阻塞和解阻塞线程的方法，这些线程不会遇到导致已弃用的方法Thread.suspend和Thread.resume无法用于以下问题：由于许可，在调用park的一个线程与试图进行unpark的另一个线程之间的竞争将保留生命力。此外，如果调用者的线程被中断并且支持超时版本，则park将返回。 park方法也可能在其他任何时间出于“无理由”返回，因此通常必须在循环中调用该循环，该循环在返回时会重新检查条件。从这个意义上说，park是对“繁忙等待”的优化，它不会浪费太多的时间，而必须与unpark配对才能生效。
了解了其作用，我们看看相关API。

LockSupport.park()

park():除非有许可，否则出于线程调度目的禁用当前线程。
如果许可证可用，则将其消耗掉，并立即返回呼叫；否则，将立即返回该呼叫。出于线程调度的目的，当前线程将被禁用，并处于休眠状态，直到发生以下三种情况之一：
1.其他一些线程以当前线程为目标调用unpark()方法
2.其他一些线程Threadinterrupt interrupts当前线程
3.虚假地调用返回
源码：

1. public static void park() {
2. UNSAFE.park(false, 0L);
3. }

LockSupport都是调用的UNSAFE的方法，我们先看看park方法

1. public class LockSupportMain {
2. public static void main(String[] args) {
3. System.out.println("begin park!");
4. LockSupport.park();
5. System.out.println("end park!");
6. }
7. }

运行结果：

我们调用了park方法，导致Main线程一直被阻塞，一直没有结束，因为默认的情况下，调用线程是不持有许可证的，我们如何解决呢？上面提到过三个方式，我们一个一个的验证。

1.调用unpack方法获得许可

unpack():如果给定线程尚不可用，则使它可用。如果线程在park上被阻止，则它将取消阻止。否则，将确保其对park的下一次调用不会阻塞。如果给定线程尚未启动，则不能保证此操作完全无效。
源码：

1. public static void unpark(Thread thread) {
2. if (thread != null)
3. UNSAFE.unpark(thread);
4. }

1. public class LockSupportMain2 {
2. public static void main(String[] args) {
3. System.out.println("begin park!");
4. LockSupport.unpark(Thread.currentThread());
5. LockSupport.park();
6. System.out.println("end park!");
7. }
8. }

运行结果：

可以看出，当前的线程main已经释放了，没有进行阻塞，直接运行完成了。
我们创建一个线程有Main线程进行unpark方法将线程在阻塞的情况下，进行运行。

1. public class LockSupportMain3 {
2.  
3. public static void main(String[] args) throws InterruptedException {
4. Runnable runnable = new Runnable() {
5. @Override
6. public void run() {
7. System.out.println("begin start thread name: " + Thread.currentThread().getName() + " park");
8. LockSupport.park();
9. System.out.println("end start thread name: " + Thread.currentThread().getName() + " park");
10. }
11. };
12.  
13. Thread thread = new Thread(runnable);
14. thread.start();
15. Thread.sleep(2000);
16. System.out.println("main thread call unpark");
17. LockSupport.unpark(thread);
18. }
19.  
20. }

运行结果：

运行结果可以看出，其他一些线程以当前线程为目标调用unpark()方法可以将线程的park导致阻塞的继续运行。

2.调用中断interrupts方法获得许可

由于park方法不会告诉你何种原因返回，所以调用者需要根据之前调用park方法的原因，再次检查条件是否满足，如果不能满足，就还需要调用park方法

1. public class LockSupportMain4 {
2.  
3. public static void main(String[] args) throws InterruptedException {
4. Runnable runnable = new Runnable() {
5. @Override
6. public void run() {
7. System.out.println("begin start thread name: " + Thread.currentThread().getName() + " park");
8. while (!Thread.currentThread().isInterrupted()) {
9. LockSupport.park();
10. }
11. System.out.println("end start thread name: " + Thread.currentThread().getName() + " park");
12. }
13. };
14.  
15. Thread thread = new Thread(runnable);
16. thread.start();
17. Thread.sleep(2000);
18. //通过interrupt方法 让park阻塞继续运行
19. thread.interrupt();
20. }
21.  
22. }

运行结果：

由运行可以看出，其他一些线程Threadinterrupt interrupts当前线程是可以将park阻塞的线程继续运行。

parkNanos(long nanos)

parkNanos(long nanos)：除非允许使用许可，否则在指定的等待时间内禁用用于线程调度的当前线程。
源码：

1. public static void parkNanos(long nanos) {
2. if (nanos > 0)
3. UNSAFE.park(false, nanos);
4. }

1. public class LockSupportMain5 {
2.  
3. public static void main(String[] args) throws InterruptedException {
4. Runnable runnable = new Runnable() {
5. @Override
6. public void run() {
7. System.out.println("begin start thread name: " + Thread.currentThread().getName() + " park");
8. LockSupport.parkNanos(3_000_000_000L);
9. System.out.println("end start thread name: " + Thread.currentThread().getName() + " park");
10. }
11. };
12. Thread thread = new Thread(runnable);
13. thread.start();
14. }
15. }

运行结果：

三秒之后，阻塞三秒之后继续运行。

park(Object blocker)

park(Object blocker)：除非有许可，否则出于线程调度目的禁用当前线程
源码：

1. public static void park(Object blocker) {
2. Thread t = Thread.currentThread();
3. setBlocker(t, blocker);
4. UNSAFE.park(false, 0L);
5. setBlocker(t, null);
6. }

这里的blocker对象是Thread类中的blocker对象，代码如下：

1. //提供给java.util.concurrent.locks.LockSupport.park的当前调用的参数。
2. //由（私有）java.util.concurrent.locks.LockSupport.setBlocker设置使用
3. //java.util.concurrent.locks.LockSupport.getBlocker进行访问
4. volatile Object parkBlocker;

parkNanos(Object blocker, long nanos)

源码：

1. public static void parkNanos(Object blocker, long nanos) {
2. if (nanos > 0) {
3. Thread t = Thread.currentThread();
4. setBlocker(t, blocker);
5. UNSAFE.park(false, nanos);
6. setBlocker(t, null);
7. }
8. }

parkUntil(Object blocker, long deadline)

parkUntil(Object blocker, long deadline):除非指定许可，否则禁用当前线程以进行线程调度，直到指定的期限。
源码：

1. public static void parkUntil(Object blocker, long deadline) {
2. Thread t = Thread.currentThread();
3. setBlocker(t, blocker);
4. UNSAFE.park(true, deadline);
5. setBlocker(t, null);
6. }

我们使用java API中的例子看看：

1. public class LockSupportMain6 {
2. private final AtomicBoolean locked = new AtomicBoolean(false);
3. private final Queue<Thread> waiters
4. = new ConcurrentLinkedQueue<Thread>();
5.  
6. public void lock() {
7. boolean wasInterrupted = false;
8. Thread current = Thread.currentThread();
9. waiters.add(current);
10.  
11. // 不在队列中时先阻塞或无法获取锁定
12. while (waiters.peek() != current ||
13. !locked.compareAndSet(false, true)) {
14. LockSupport.park(this);
15. // 等待时忽略中断 如果park方法是因为被中断而返回，则忽略中断，并且重新设置中断标记，做个标记
16. if (Thread.interrupted()) {
17. wasInterrupted = true;
18. }
19. }
20. waiters.remove();
21. // 退出时重新声明中断状态
22. if (wasInterrupted)
23. {
24. current.interrupt();
25. }
26. }
27. public void unlock() {
28. locked.set(false);
29. LockSupport.unpark(waiters.peek());
30. }
31. }

有blocker的可以传递给开发人员更多的现场信息，可以查看到当前线程的阻塞对象，方便定位问题

到此这篇关于教你如何使用Java多线程编程-LockSupport工具类的文章就介绍到这了,更多相关使用java的LockSupport工具类内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/qian1314520hu/article/details/115667930