java高并發系列 - 第14天：JUC中的LockSupport工具類，必備技能

這是java高并發系列第14篇文章。

本文主要内容：

講解3種讓線程等待和喚醒的方法，每種方法配合具體的示例

介紹LockSupport主要用法

對比3種方式，了解他們之間的差別

LockSupport位于java.util.concurrent（簡稱juc）包中，算是juc中一個基礎類，juc中很多地方都會使用LockSupport，非常重要，希望大家一定要掌握。

關于線程等待/喚醒的方法，前面的文章中我們已經講過2種了：

方式1：使用Object中的wait()方法讓線程等待，使用Object中的notify()方法喚醒線程

方式2：使用juc包中Condition的await()方法讓線程等待，使用signal()方法喚醒線程

這2種方式，我們先來看一下示例。

使用Object類中的方法實作線程等待和喚醒

示例1：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

/**

微信公衆号：路人甲Java，專注于java技術分享（帶你玩轉爬蟲、分布式事務、異步消息服務、任務排程、分庫分表、大資料等），喜歡請關注！

*/

public class Demo1 {

static Object lock = new Object();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        synchronized (lock) {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被喚醒!");
        }
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(5);
    synchronized (lock) {
        lock.notify();
    }
}

}

輸出：

1563592938744,t1 start!

1563592943745,t1 被喚醒!

t1線程中調用lock.wait()方法讓t1線程等待，主線程中休眠5秒之後，調用lock.notify()方法喚醒了t1線程，輸出的結果中，兩行結果相差5秒左右，程式正常退出。

示例2

我們把上面代碼中main方法内部改一下，删除了synchronized關鍵字，看看有什麼效果：

public class Demo2 {

static Object lock = new Object();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被喚醒!");
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(5);
    lock.notify();
}

運作結果：

Exception in thread "t1" java.lang.IllegalMonitorStateException

1563593178811,t1 start!

at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:502)
at com.itsoku.chat10.Demo2.lambda$main$0(Demo2.java:16)
at java.lang.Thread.run(Thread.java:745)

Exception in thread "main" java.lang.IllegalMonitorStateException

at java.lang.Object.notify(Native Method)
at com.itsoku.chat10.Demo2.main(Demo2.java:26)

上面代碼中将synchronized去掉了，發現調用wait()方法和調用notify()方法都抛出了IllegalMonitorStateException異常，原因：Object類中的wait、notify、notifyAll用于線程等待和喚醒的方法，都必須在同步代碼中運作（必須用到關鍵字synchronized）。

示例3

喚醒方法在等待方法之前執行，線程能夠被喚醒麼？代碼如下：

public class Demo3 {

static Object lock = new Object();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lock) {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            try {
                //休眠3秒
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被喚醒!");
        }
    });
    t1.setName("t1");
    t1.start();
    //休眠1秒之後喚醒lock對象上等待的線程
    TimeUnit.SECONDS.sleep(1);
    synchronized (lock) {
        lock.notify();
    }
    System.out.println("lock.notify()執行完畢");
}

運作代碼，輸出結果：

lock.notify()執行完畢

1563593869797,t1 start!

輸出了上面2行之後，程式一直無法結束，t1線程調用wait()方法之後無法被喚醒了，從輸出中可見，notify()方法在wait()方法之前執行了，等待的線程無法被喚醒了。說明：喚醒方法在等待方法之前執行，線程無法被喚醒。

關于Object類中的使用者線程等待和喚醒的方法，總結一下：

wait()/notify()/notifyAll()方法都必須放在同步代碼（必須在synchronized内部執行）中執行，需要先擷取鎖

線程喚醒的方法（notify、notifyAll）需要在等待的方法（wait）之後執行，等待中的線程才可能會被喚醒，否則無法喚醒

使用Condition實作線程的等待和喚醒

Condition的使用，前面的文章講過，對這塊不熟悉的可以移步JUC中Condition的使用，關于Condition我們準備了3個示例。

示例1

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

public class Demo4 {

static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        lock.lock();
        try {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被喚醒!");
        } finally {
            lock.unlock();
        }
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(5);
    lock.lock();
    try {
        condition.signal();
    } finally {
        lock.unlock();
    }

}

1563594349632,t1 start!

1563594354634,t1 被喚醒!

t1線程啟動之後調用condition.await()方法将線程處于等待中，主線程休眠5秒之後調用condition.signal()方法将t1線程喚醒成功，輸出結果中2個時間戳相差5秒。

我們将上面代碼中的lock.lock()、lock.unlock()去掉，看看會發生什麼。代碼：

public class Demo5 {

static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
        try {
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被喚醒!");
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(5);
    condition.signal();
}

1563594654865,t1 start!

at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.fullyRelease(AbstractQueuedSynchronizer.java:1723)
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2036)
at com.itsoku.chat10.Demo5.lambda$main$0(Demo5.java:19)
at java.lang.Thread.run(Thread.java:745)

at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.signal(AbstractQueuedSynchronizer.java:1939)
at com.itsoku.chat10.Demo5.main(Demo5.java:29)

有異常發生，condition.await();和condition.signal();都觸發了IllegalMonitorStateException異常。原因：調用condition中線程等待和喚醒的方法的前提是必須要先擷取lock的鎖。

喚醒代碼在等待之前執行，線程能夠被喚醒麼？代碼如下：

public class Demo6 {

static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.lock();
        try {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被喚醒!");
        } finally {
            lock.unlock();
        }
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(1);
    lock.lock();
    try {
        condition.signal();
    } finally {
        lock.unlock();
    }
    System.out.println(System.currentTimeMillis() + ",condition.signal();執行完畢");
}

運作結果:

1563594886532,condition.signal();執行完畢

1563594890532,t1 start!

輸出上面2行之後，程式無法結束，代碼結合輸出可以看出signal()方法在await()方法之前執行的，最終t1線程無法被喚醒，導緻程式無法結束。

關于Condition中方法使用總結：

使用Condtion中的線程等待和喚醒方法之前，需要先擷取鎖。否者會報IllegalMonitorStateException異常

signal()方法先于await()方法之前調用，線程無法被喚醒

Object和Condition的局限性

關于Object和Condtion中線程等待和喚醒的局限性，有以下幾點：

2中方式中的讓線程等待和喚醒的方法能夠執行的先決條件是：線程需要先擷取鎖

喚醒方法需要在等待方法之後調用，線程才能夠被喚醒

關于這2點，LockSupport都不需要，就能實作線程的等待和喚醒。下面我們來說一下LockSupport類。

LockSupport類介紹

LockSupport類可以阻塞目前線程以及喚醒指定被阻塞的線程。主要是通過park()和unpark(thread)方法來實作阻塞和喚醒線程的操作的。

每個線程都有一個許可(permit)，permit隻有兩個值1和0，預設是0。

當調用unpark(thread)方法，就會将thread線程的許可permit設定成1(注意多次調用unpark方法，不會累加，permit值還是1)。

當調用park()方法，如果目前線程的permit是1，那麼将permit設定為0，并立即傳回。如果目前線程的permit是0，那麼目前線程就會阻塞，直到别的線程将目前線程的permit設定為1時，park方法會被喚醒，然後會将permit再次設定為0，并傳回。

注意：因為permit預設是0，是以一開始調用park()方法，線程必定會被阻塞。調用unpark(thread)方法後，會自動喚醒thread線程，即park方法立即傳回。

LockSupport中常用的方法

阻塞線程

void park()：阻塞目前線程，如果調用unpark方法或者目前線程被中斷，從能從park()方法中傳回

void park(Object blocker)：功能同方法1，入參增加一個Object對象，用來記錄導緻線程阻塞的阻塞對象，友善進行問題排查

void parkNanos(long nanos)：阻塞目前線程，最長不超過nanos納秒，增加了逾時傳回的特性

void parkNanos(Object blocker, long nanos)：功能同方法3，入參增加一個Object對象，用來記錄導緻線程阻塞的阻塞對象，友善進行問題排查

void parkUntil(long deadline)：阻塞目前線程，直到deadline，deadline是一個絕對時間，表示某個時間的毫秒格式

void parkUntil(Object blocker, long deadline)：功能同方法5，入參增加一個Object對象，用來記錄導緻線程阻塞的阻塞對象，友善進行問題排查；

喚醒線程

void unpark(Thread thread):喚醒處于阻塞狀态的指定線程

主線程線程等待5秒之後，喚醒t1線程，代碼如下：

import java.util.concurrent.locks.LockSupport;

public class Demo7 {

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
        LockSupport.park();
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被喚醒!");
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(5);
    LockSupport.unpark(t1);
    System.out.println(System.currentTimeMillis() + ",LockSupport.unpark();執行完畢");
}

1563597664321,t1 start!

1563597669323,LockSupport.unpark();執行完畢

1563597669323,t1 被喚醒!

t1中調用LockSupport.park();讓目前線程t1等待，主線程休眠了5秒之後，調用LockSupport.unpark(t1);将t1線程喚醒，輸出結果中1、3行結果相差5秒左右，說明t1線程等待5秒之後，被喚醒了。

LockSupport.park();無參數，内部直接會讓目前線程處于等待中；unpark方法傳遞了一個線程對象作為參數，表示将對應的線程喚醒。

喚醒方法放在等待方法之前執行，看一下線程是否能夠被喚醒呢？代碼如下：

public class Demo8 {

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
        LockSupport.park();
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被喚醒!");
    });
    t1.setName("t1");
    t1.start();
    //休眠1秒
    TimeUnit.SECONDS.sleep(1);
    LockSupport.unpark(t1);
    System.out.println(System.currentTimeMillis() + ",LockSupport.unpark();執行完畢");
}

1563597994295,LockSupport.unpark();執行完畢

1563597998296,t1 start!

1563597998296,t1 被喚醒!

代碼中啟動t1線程，t1線程内部休眠了5秒，然後主線程休眠1秒之後，調用了LockSupport.unpark(t1);喚醒線程t1，此時LockSupport.park();方法還未執行，說明喚醒方法在等待方法之前執行的；輸出結果中2、3行結果時間一樣，表示LockSupport.park();沒有阻塞了，是立即傳回的。

說明：喚醒方法在等待方法之前執行，線程也能夠被喚醒，這點是另外2中方法無法做到的。Object和Condition中的喚醒必須在等待之後調用，線程才能被喚醒。而LockSupport中，喚醒的方法不管是在等待之前還是在等待之後調用，線程都能夠被喚醒。

park()讓線程等待之後，是否能夠響應線程中斷？代碼如下：

public class Demo9 {

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
        System.out.println(Thread.currentThread().getName() + ",park()之前中斷标志：" + Thread.currentThread().isInterrupted());
        LockSupport.park();
        System.out.println(Thread.currentThread().getName() + ",park()之後中斷标志：" + Thread.currentThread().isInterrupted());
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被喚醒!");
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(5);
    t1.interrupt();

}

1563598536736,t1 start!

t1,park()之前中斷标志：false

t1,park()之後中斷标志：true

1563598541736,t1 被喚醒!

t1線程中調用了park()方法讓線程等待，主線程休眠了5秒之後，調用t1.interrupt();給線程t1發送中斷信号，然後線程t1從等待中被喚醒了，輸出結果中的1、4行結果相差5秒左右，剛好是主線程休眠了5秒之後将t1喚醒了。結論：park方法可以相應線程中斷。

LockSupport.park方法讓線程等待之後，喚醒方式有2種：

調用LockSupport.unpark方法

調用等待線程的interrupt()方法，給等待的線程發送中斷信号，可以喚醒線程

示例4

LockSupport有幾個阻塞放有一個blocker參數，這個參數什麼意思，上一個執行個體代碼，大家一看就懂了：

public class Demo10 {

static class BlockerDemo {
}

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        LockSupport.park();
    });
    t1.setName("t1");
    t1.start();

    Thread t2 = new Thread(() -> {
        LockSupport.park(new BlockerDemo());
    });
    t2.setName("t2");
    t2.start();
}

運作上面代碼，然後用jstack檢視一下線程的堆棧資訊：

"t2" #13 prio=5 os_prio=0 tid=0x00000000293ea800 nid=0x91e0 waiting on condition [0x0000000029c3f000]

java.lang.Thread.State: WAITING (parking)

at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x00000007180bfeb0> (a com.itsoku.chat10.Demo10$BlockerDemo)
    at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
    at com.itsoku.chat10.Demo10.lambda$main$1(Demo10.java:22)
    at com.itsoku.chat10.Demo10

Lambda$2/824909230.run(Unknown Source)

at java.lang.Thread.run(Thread.java:745)

"t1" #12 prio=5 os_prio=0 tid=0x00000000293ea000 nid=0x9d4 waiting on condition [0x0000000029b3f000]

at sun.misc.Unsafe.park(Native Method)

at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)

at com.itsoku.chat10.Demo10.lambda$main$0(Demo10.java:16)

at com.itsoku.chat10.Demo10

Lambda$1/1389133897.run(Unknown Source)

at java.lang.Thread.run(Thread.java:745)

代碼中，線程t1和t2的不同點是，t2中調用park方法傳入了一個BlockerDemo對象，從上面的線程堆棧資訊中，發現t2線程的堆棧資訊中多了一行- parking to wait for <0x00000007180bfeb0> (a com.itsoku.chat10.Demo10$BlockerDemo)，剛好是傳入的BlockerDemo對象，park傳入的這個參數可以讓我們線上程堆棧資訊中友善排查問題，其他暫無他用。

LockSupport的其他等待方法，包含有逾時時間了，過了逾時時間，等待方法會自動傳回，讓線程繼續運作，這些方法在此就不提供示例了，有興趣的朋友可以自己動動手，練一練。

線程等待和喚醒的3種方式做個對比

到目前為止，已經說了3種讓線程等待和喚醒的方法了

方式1：Object中的wait、notify、notifyAll方法

方式2：juc中Condition接口提供的await、signal、signalAll方法

方式3：juc中的LockSupport提供的park、unpark方法

3種方式對比：

Object Condtion LockSupport

前置條件需要在synchronized中運作需要先擷取Lock的鎖無

無限等待支援支援支援

逾時等待支援支援支援

等待到将來某個時間傳回不支援支援支援

等待狀态中釋放鎖會釋放會釋放不會釋放

喚醒方法先于等待方法執行，能否喚醒線程否否可以

是否能響應線程中斷是是是

線程中斷是否會清除中斷标志是是否

是否支援等待狀态中不響應中斷不支援支援不支援

原文位址

https://www.cnblogs.com/itsoku123/p/11218416.html

java高并發系列 - 第14天：JUC中的LockSupport工具類，必備技能

繼續閱讀

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

Ambari介紹和架構原理

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

NOSQL安全攻擊

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method