Java多线程--LockSupport

╰+攻爆jí腚メ 2022-06-05 05:54 181阅读 0赞

原文：[http://www.cnblogs.com/skywang12345/p/3505784.html][http_www.cnblogs.com_skywang12345_p_3505784.html]

### **概述** ###

本章介绍JUC(java.util.concurrent)包中的LockSupport。内容包括：  
[LockSupport介绍][LockSupport]  
[LockSupport函数列表][LockSupport 1]  
[LockSupport参考代码(基于JDK1.7.0\_40)][LockSupport_JDK1.7.0_40]  
[LockSupport示例][LockSupport 2]

转载请注明出处：[http://www.cnblogs.com/skywang12345/p/3505784.html][http_www.cnblogs.com_skywang12345_p_3505784.html]

### **LockSupport介绍** ###

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。   
LockSupport中的park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程，而且park()和unpark()不会遇到“Thread.suspend 和 Thread.resume所可能引发的死锁”问题。  
因为park() 和 unpark()有许可的存在；调用 park() 的线程和另一个试图将其 unpark() 的线程之间的竞争将保持活性。

### **LockSupport函数列表** ###

![复制代码][copycode.gif]

// 返回提供给最近一次尚未解除阻塞的 park 方法调用的 blocker 对象，如果该调用不受阻塞，则返回 null。
    static Object getBlocker(Thread t)
    // 为了线程调度，禁用当前线程，除非许可可用。
    static void park()
    // 为了线程调度，在许可可用之前禁用当前线程。
    static void park(Object blocker)
    // 为了线程调度禁用当前线程，最多等待指定的等待时间，除非许可可用。
    static void parkNanos(long nanos)
    // 为了线程调度，在许可可用前禁用当前线程，并最多等待指定的等待时间。
    static void parkNanos(Object blocker, long nanos)
    // 为了线程调度，在指定的时限前禁用当前线程，除非许可可用。
    static void parkUntil(long deadline)
    // 为了线程调度，在指定的时限前禁用当前线程，除非许可可用。
    static void parkUntil(Object blocker, long deadline)
    // 如果给定线程的许可尚不可用，则使其可用。
    static void unpark(Thread thread)

![复制代码][copycode.gif]

### **LockSupport参考代码(基于JDK1.7.0\_40)** ###

LockSupport.java的源码如下：

![ContractedBlock.gif][]

**说明**：LockSupport是通过调用Unsafe函数中的接口实现阻塞和解除阻塞的。

### **LockSupport示例** ###

对比下面的“示例1”和“示例2”可以更清晰的了解LockSupport的用法。

**示例1**

![复制代码][copycode.gif]

1 public class WaitTest1 {
     2 
     3     public static void main(String[] args) {
     4 
     5         ThreadA ta = new ThreadA("ta");
     6 
     7         synchronized(ta) { // 通过synchronized(ta)获取“对象ta的同步锁”
     8             try {
     9                 System.out.println(Thread.currentThread().getName()+" start ta");
    10                 ta.start();
    11 
    12                 System.out.println(Thread.currentThread().getName()+" block");
    13                 // 主线程等待
    14                 ta.wait();
    15 
    16                 System.out.println(Thread.currentThread().getName()+" continue");
    17             } catch (InterruptedException e) {
    18                 e.printStackTrace();
    19             }
    20         }
    21     }
    22 
    23     static class ThreadA extends Thread{
    24 
    25         public ThreadA(String name) {
    26             super(name);
    27         }
    28 
    29         public void run() {
    30             synchronized (this) { // 通过synchronized(this)获取“当前对象的同步锁”
    31                 System.out.println(Thread.currentThread().getName()+" wakup others");
    32                 notify();    // 唤醒“当前对象上的等待线程”
    33             }
    34         }
    35     }
    36 }

![复制代码][copycode.gif]

**示例2**

![复制代码][copycode.gif]

1 import java.util.concurrent.locks.LockSupport;
     2 
     3 public class LockSupportTest1 {
     4 
     5     private static Thread mainThread;
     6 
     7     public static void main(String[] args) {
     8 
     9         ThreadA ta = new ThreadA("ta");
    10         // 获取主线程
    11         mainThread = Thread.currentThread();
    12 
    13         System.out.println(Thread.currentThread().getName()+" start ta");
    14         ta.start();
    15 
    16         System.out.println(Thread.currentThread().getName()+" block");
    17         // 主线程阻塞
    18         LockSupport.park(mainThread);
    19 
    20         System.out.println(Thread.currentThread().getName()+" continue");
    21     }
    22 
    23     static class ThreadA extends Thread{
    24 
    25         public ThreadA(String name) {
    26             super(name);
    27         }
    28 
    29         public void run() {
    30             System.out.println(Thread.currentThread().getName()+" wakup others");
    31             // 唤醒“主线程”
    32             LockSupport.unpark(mainThread);
    33         }
    34     }
    35 }

![复制代码][copycode.gif]

**运行结果**：

main start ta
    main block
    ta wakup others
    main continue

**说明**：park和wait的区别。wait让线程阻塞前，必须通过synchronized获取同步锁。

[http_www.cnblogs.com_skywang12345_p_3505784.html]: http://www.cnblogs.com/skywang12345/p/3505784.html
[LockSupport]: http://www.cnblogs.com/skywang12345/p/3505784.html#a1
[LockSupport 1]: http://www.cnblogs.com/skywang12345/p/3505784.html#a2
[LockSupport_JDK1.7.0_40]: http://www.cnblogs.com/skywang12345/p/3505784.html#a3
[LockSupport 2]: http://www.cnblogs.com/skywang12345/p/3505784.html#a4
[copycode.gif]: /images/20220605/f70a2f9a09534b3c8d93105b731826d6.png
[ContractedBlock.gif]: /images/20220605/95c6e0e14f7a46eea4affd86ad9df27f.png