Java線程休眠的5種方法

更新時間：2022年05月08日 15:07:05 作者：??Java中文社群????

這篇文章主要介紹了Java線程休眠的5種方法，分別是Thread.sleep、TimeUnit、wait、Condition、LockSupport，下面文章將對這五種方法進行詳細講解，需要的小伙伴可以參考一下

方法1：Thread.sleep

Thread.sleep 方法來自于 Thread 類，它是一個 native 本地方法，其實現(xiàn)源碼如下：

public static native void sleep(long millis) throws InterruptedException;

Thread.sleep 方法需要傳遞一個 long 類型的毫秒數(shù)，表示 n 毫秒之后自動喚醒，它的基礎(chǔ)用法如下：

Thread t1 = new Thread() {
    @Override
    public void run() {
        System.out.println("線程執(zhí)行：" + LocalDateTime.now());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("線程結(jié)束：" + LocalDateTime.now());
    }
};
t1.start();

以上程序的執(zhí)行結(jié)果如下圖所示：

方法2：TimeUnit

sleep 方法因為要傳遞一個毫秒類型的參數(shù)，因此在設(shè)置大一點的時間時比較麻煩，比如設(shè)置 1 小時或 1 天時，此時我們就可以使用 TimeUnit 來替代 sleep 方法實現(xiàn)休眠。 TimeUnit 的功能和 sleep 一樣，讓線程休眠 N 個單位時間之后自動喚醒，它的基礎(chǔ)用法如下：

Thread t1 = new Thread() {
    @Override
    public void run() {
        System.out.println("線程執(zhí)行：" + LocalDateTime.now());
        try {
            TimeUnit.SECONDS.sleep(1); // 休眠 1s
            //TimeUnit.DAYS.sleep(1); // 休眠 1 天
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("線程結(jié)束：" + LocalDateTime.now());
    }
};
t1.start();

以上程序的執(zhí)行結(jié)果如下圖所示：

當我們查看 TimeUnit 源碼時就會發(fā)現(xiàn)，它的底層是基于 Thread.sleep 方法實現(xiàn)的，其實現(xiàn)源碼如下：

方法3：wait

wait/notify/notifyAll 都來自于 Object 類，其中：

wait() / wait(long timeout)：表示讓當前線程進入休眠狀態(tài)。
notify()：喚醒當前對象上的一個休眠線程。
notifyAll()：喚醒當前對象上的所有休眠線程。

其中 wait() 方法表示讓當前線程無限期等待下去，直到遇到 notify/notifyAll 方法時才會被喚醒，而 wait(long timeout) 表示接收一個 long 類型的超時時間，如果沒有遇到 notify/notifyAll 會在 long 毫秒之后自動喚醒，如果遇到了 notify/notifyAll 方法會立即被喚醒。它的基礎(chǔ)用法如下：

Object lock = new Object();
new Thread(() -> {
    synchronized (lock) {
        try {
            // 讓當前線程休眠
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}).start();
synchronized (lock) {
    lock.notify(); // 喚醒當前對象上一個休眠線程
    // lock.notifyAll(); // 喚醒當前對象上所有休眠的線程
}

需要注意的是 wait/notify/notifyAll 在使用時必須要配合 synchronized 一起使用，否則程序執(zhí)行會報錯。

方法4：Condition

Condition 作為 wait 的升級版，它提供的常用方法有以下幾個：

await()：讓當前線程進入等待狀態(tài)，直到被通知（signal）或者被中斷時才會繼續(xù)執(zhí)行。
awaitUninterruptibly()：讓當前線程進入等待狀態(tài)，直到被通知才會被喚醒，它對線程的中斷通知不做響應(yīng)。
await(long time, TimeUnit unit)：在 await() 方法的基礎(chǔ)上添加了超時時間，如果過了超時時間還沒有遇到喚醒方法則會自動喚醒并恢復(fù)執(zhí)行。
awaitUntil(Date deadline)：讓當前線程進入等待狀態(tài)，如果沒有遇到喚醒方法也會在設(shè)置的時間之后自動喚醒。
signal()：喚醒一個等待在 Condition 上的線程。
signalAll()：喚醒等待在 Condition 上所有的線程。

它的基本用法如下：

import java.time.LocalDateTime;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionExample {
    public static void main(String[] args) throws InterruptedException {
        // 創(chuàng)建鎖
        final Lock lock = new ReentrantLock();
        // 創(chuàng)建 Condition
        final Condition condition = lock.newCondition();
        new Thread(() -> {
            System.out.println("線程執(zhí)行：" + LocalDateTime.now());
            lock.lock(); // 得到鎖
            try {
                // 休眠線程
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock(); // 釋放鎖
            }
            System.out.println("線程結(jié)束：" + LocalDateTime.now());
        }).start();
        Thread.sleep(1000);
        lock.lock(); // 得到鎖
        try {
            // 喚醒線程
            condition.signal();
        } finally {
            lock.unlock(); // 釋放鎖
        }
    }
}

相比于 wait 方法，Condition 對象更加靈活，因為它可以在一把鎖上定義多個 Condition 對象進行使用，

如下代碼所示：

 // 創(chuàng)建鎖
final Lock lock = new ReentrantLock();
// 創(chuàng)建 Condition 1
final Condition condition = lock.newCondition();
// 創(chuàng)建 Condition 2
final Condition condition2 = lock.newCondition();
// ......

方法5：LockSupport

LockSupport 是更加底層的操作線程休眠和喚醒的對象，它提供了兩個常用的方法：

LockSupport.park()：休眠當前線程。
LockSupport.unpark(Thread thread)：喚醒一個指定的線程。

它的基礎(chǔ)用法如下：

Thread t1 = new Thread(() -> {
    System.out.println("線程1休眠");
    LockSupport.park(); // 休眠線程
    System.out.println("線程1執(zhí)行結(jié)束");
}, "線程1");
t1.start();

Thread t2 = new Thread(() -> {
    System.out.println("線程2休眠");
    LockSupport.park(); // 休眠線程
    System.out.println("線程2執(zhí)行結(jié)束");
}, "線程2");
t2.start();

Thread t3 = new Thread(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("喚醒線程1");
    LockSupport.unpark(t1); // 喚醒線程1
}, "線程3");
t3.start();

以上程序的執(zhí)行結(jié)果如下圖所示：

總結(jié)

Thread.sleep 和 TimeUnit 是讓線程休眠并在一段時間后自動喚醒，而 wait、Condition、LockSupport 提供了休眠和喚醒線程的方法，其中 Condition 為 wait 方法的升級版，而 LockSupport 是更底層的讓線程休眠和喚醒的方法，它可以實現(xiàn)喚醒某個指定的線程，這是其它方法所不具備的（功能）。

您可能感興趣的文章: