Java——线程睡眠全方位解析

骑猪看日落 2024-03-23 22:17 26阅读 0赞

## **线程睡眠的方法：** ##

在 Java 中，让线程休眠的方法有很多，这些方法大致可以分为两类，一类是设置时间，在一段时间后自动唤醒，而另一个类是提供了一对休眠和唤醒的方法，在线程休眠之后，可以在任意时间对线程进行唤醒。

**线程睡眠的方法有以下 5 个：**

>  *  Thread.sleep
>  *  TimeUnit
>  *  wait
>  *  Condition
>  *  LockSupport

其中 sleep 和 TimeUnit 是让线程睡眠一段时间后自动唤醒，而 wait、Condition、LockSupport 提供了一对休眠和唤醒线程的方法，可以实现任意时刻唤醒某个线程。

### 方法1：Thread.sleep ###

`Thread`类的`sleep()`方法用于在指定的时间内睡眠线程。

**java中sleep()方法的语法**  
`Thread`类为睡眠线程提供了两种方法:

public static void sleep(long miliseconds)throws InterruptedException
    public static void sleep(long miliseconds, int nanos)throws InterruptedException

**以上程序的执行结果如下图所示：**

class TestSleepMethod1 extends Thread {
        public void run() {
            for (int i = 1; i < 5; i++) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    System.out.println(e);
                }
                System.out.println(i);
            }
        }
    
        public static void main(String args[]) {
            TestSleepMethod1 t1 = new TestSleepMethod1();
            TestSleepMethod1 t2 = new TestSleepMethod1();
    
            t1.start();
            t2.start();
        }
    }

**以上程序的执行结果如下所示：**

> 1 1 2 2 3 3 4 4

### 方法2：TimeUnit ###

sleep 方法因为要传递一个毫秒类型的参数，因此在设置大一点的时间时比较麻烦，比如设置 1 小时或 1 天时，此时我们就可以使用 TimeUnit 来替代 sleep 方法实现休眠。

**TimeUnit 的功能和 sleep 一样，让线程休眠 N 个单位时间之后自动唤醒**，**它的基础用法如下：**

**以上程序的执行结果如下图所示：**

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

![13a2b5a52073483685773611b052ce10.png][]

**当我们查看 TimeUnit 源码时就会发现，它的底层是基于 Thread.sleep 方法实现的，其实现源码如下：**

![bf363b1e9e25452eaafba0e316545077.png][]

### 方法3：wait ###

wait/notify/notifyAll 都来自于 Object 类，**其中：**

>  *  **wait() / wait(long timeout)：**表示让当前线程进入休眠状态。
>  *  **notify()：**唤醒当前对象上的一个休眠线程。
>  *  **notifyAll()：**唤醒当前对象上的所有休眠线程。

其中 wait() 方法表示让当前线程无限期等待下去，直到遇到 notify/notifyAll 方法时才会被唤醒，而 wait(long timeout) 表示接收一个 long 类型的超时时间，如果没有遇到 notify/notifyAll 会在 long 毫秒之后自动唤醒，如果遇到了 notify/notifyAll 方法会立即被唤醒。 它的基础用法如下：

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 一起使用，否则程序执行会报错。

### 方法4：Condition ###

Condition 作为 wait 的升级版，它提供的常用方法有以下几个：

>  *  **await()：**让当前线程进入等待状态，直到被通知（signal）或者被中断时才会继续执行。
>  *  **awaitUninterruptibly()：**让当前线程进入等待状态，直到被通知才会被唤醒，它对线程的中断通知不做响应。
>  *  **await(long time, TimeUnit unit)**：在 await() 方法的基础上添加了超时时间，如果过了超时时间还没有遇到唤醒方法则会自动唤醒并恢复执行。
>  *  **awaitUntil(Date deadline)：**让当前线程进入等待状态，如果没有遇到唤醒方法也会在设置的时间之后自动唤醒。
>  *  **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 {
            // 创建锁
            final Lock lock = new ReentrantLock();
            // 创建 Condition
            final Condition condition = lock.newCondition();
            new Thread(() -> {
                System.out.println("线程执行：" + LocalDateTime.now());
                lock.lock(); // 得到锁
                try {
                    // 休眠线程
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock(); // 释放锁
                }
                System.out.println("线程结束：" + LocalDateTime.now());
            }).start();
            Thread.sleep(1000);
            lock.lock(); // 得到锁
            try {
                // 唤醒线程
                condition.signal();
            } finally {
                lock.unlock(); // 释放锁
            }
        }
    }

相比于 wait 方法，Condition 对象更加灵活，因为它可以在一把锁上定义多个 Condition 对象进行使用，

**如下代码所示：**

// 创建锁
    final Lock lock = new ReentrantLock();
    // 创建 Condition 1
    final Condition condition = lock.newCondition();
    // 创建 Condition 2
    final Condition condition2 = lock.newCondition();
    // ......

### 方法5：LockSupport ###

LockSupport 是更加底层的操作线程休眠和唤醒的对象，**它提供了两个常用的方法：**

>  *  **LockSupport.park()：**休眠当前线程。
>  *  **LockSupport.unpark(Thread thread)：**唤醒一个指定的线程。

**它的基础用法如下：**

Thread t1 = new Thread(() -> {
    
        System.out.println("线程1休眠");
    
        LockSupport.park(); // 休眠线程
    
        System.out.println("线程1执行结束");
    
    }, "线程1");
    
    t1.start();
    
    
    Thread t2 = new Thread(() -> {
    
        System.out.println("线程2休眠");
    
        LockSupport.park(); // 休眠线程
    
        System.out.println("线程2执行结束");
    
    }, "线程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();

**以上程序的执行结果如下图所示：**

![778b320e71b1401cba10f910d7edd1ad.png][]

### 方法总结 ###

Thread.sleep 和 TimeUnit 是让线程休眠并在一段时间后自动唤醒，而 wait、Condition、LockSupport 提供了休眠和唤醒线程的方法，其中 Condition 为 wait 方法的升级版，而 LockSupport 是更底层的让线程休眠和唤醒的方法，它可以实现唤醒某个指定的线程，这是其它方法所不具备的（功能）。

## 线程睡眠的作用 ##

线程睡眠可以有效的控制线程的执行时间，可以让CPU资源分配更加均衡，提高程序的运行效率和稳定性。

在并发编程中，线程经常会被调度器打断，通过线程睡眠，可以让该线程“放弃”一段时间的CPU执行权，避免CPU资源浪费和竞争。另外，线程睡眠还可以用来模拟线程执行中的等待时间，例如Java中的定时器和倒计时器的实现，都离不开线程睡眠。

### 线程睡眠的注意事项 ###

在使用线程睡眠时，需要注意以下几个问题：

#### 1. InterruptedException异常 ####

在调用线程睡眠方法时，需要捕获InterruptedException异常。InterruptedException是一个检查异常，它是在调用线程的interrupt()方法后，抛出的一种异常。

Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    
        t.start();
    
        // 主线程等待子线程执行完毕
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

#### 2. 线程睡眠不会释放锁 ####

在线程睡眠期间，该线程所持有的锁并不会被释放，因此，其他线程仍将被阻塞。

synchronized (obj) {
            System.out.println("获取obj锁");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("释放obj锁");
        }

#### 3. 睡眠时间应尽量短 ####

线程睡眠的时间应尽量短，可以根据实际需要调整线程睡眠的时间。如果睡眠时间过长，会导致程序的响应时间变慢，影响用户体验。另外，需要避免不必要的线程睡眠，以免影响程序的运行效率。

#### 4. 时间单位要选对 ####

在使用TimeUnit.MILLISECONDS.sleep()方法时，需要选择正确的时间单位，比如：TimeUnit.SECONDS、TimeUnit.MINUTES、TimeUnit.HOURS等。

try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

#### 5. 线程睡眠不能保证精确 ####

线程睡眠的时间并不能保证精确，它受到操作系统和虚拟机的干扰，可能会比预期的时间长一些，因此在实际使用中，需要考虑误差范围。

### 线程睡眠的应用场景 ###

线程睡眠在实际应用中广泛使用，以下是一些常见的应用场景：

#### 1. 定时器和倒计时器 ####

定时器和倒计时器是一种常见的实现方式，可以通过线程睡眠和计时器来实现。例如，以下代码实现了一个简单的倒计时器。

for (int i = 10; i >= 0; i--) {
            System.out.println("倒计时：" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

#### 2. 多线程并发控制 ####

线程睡眠可以用来控制多个线程的并发，例如通过线程睡眠，可以让多个线程按顺序执行，而不会发生同时执行的情况。

Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj) {
                    System.out.println("t1获取obj锁");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t1释放obj锁");
                }
            }
        });
    
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                synchronized (obj) {
                    System.out.println("t2获取obj锁");
                }
            }
        });
    
        t1.start();
        t2.start();
    
        // 主线程等待子线程执行完毕
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

#### 3. 提高程序的运行效率 ####

线程睡眠可以有效的控制线程的执行时间，可以让CPU资源分配更加均衡，提高程序的运行效率和稳定性。例如，以下代码使用线程睡眠优化了图片加载的过程。

long start = System.currentTimeMillis();
        loadImages();
        long end = System.currentTimeMillis();
        System.out.println("图片加载耗时：" + (end - start) + "ms");
    
        private void loadImages() {
            for (int i = 0; i < imageUrls.length; i++) {
                loadSingleImage(imageUrls[i]);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

### 总结： ###

线程睡眠作为并发编程的重要一环，不仅可以有效的控制线程的执行时间，还可以提高程序的运行效率和稳定性，因此在实际开发中，需要合理的应用线程睡眠技术。

[13a2b5a52073483685773611b052ce10.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c63593e501124f4f96983c007b271776.png
[bf363b1e9e25452eaafba0e316545077.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/acecb325c03347ec8e4e0716522fbefd.png
[778b320e71b1401cba10f910d7edd1ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4ec86041622b42a4b4f5233128606fb5.png

Java——线程睡眠全方位解析

发表评论取消回复

还没有评论，来说两句吧...

相关阅读