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

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

线程睡眠的方法：

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

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

  • Thread.sleep
  • TimeUnit
  • wait
  • Condition
  • LockSupport

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

方法1：Thread.sleep

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

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

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

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

  1. class TestSleepMethod1 extends Thread {
  2.     public void run() {
  3.         for (int i = 1; i < 5; i++) {
  4.             try {
  5.                 Thread.sleep(500);
  6.             } catch (InterruptedException e) {
  7.                 System.out.println(e);
  8.             }
  9.             System.out.println(i);
  10.         }
  11.     }
  13.     public static void main(String args[]) {
  14.         TestSleepMethod1 t1 = new TestSleepMethod1();
  15.         TestSleepMethod1 t2 = new TestSleepMethod1();
  17.         t1.start();
  18.         t2.start();
  19.     }
  20. }

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

1 1 2 2 3 3 4 4

方法2：TimeUnit

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

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

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

  1. Thread t1 = new Thread() {
  2.     @Override
  3.     public void run() {
  4.         System.out.println("线程执行：" + LocalDateTime.now());
  5.         try {
  6.             TimeUnit.SECONDS.sleep(1); // 休眠 1s
  7.             //TimeUnit.DAYS.sleep(1); // 休眠 1 天
  8.         } catch (InterruptedException e) {
  9.             e.printStackTrace();
  10.         }
  11.         System.out.println("线程结束：" + LocalDateTime.now());
  12.     }
  13. };
  14. 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 方法会立即被唤醒。 它的基础用法如下：

  1. Object lock = new Object();
  2. new Thread(() -> {
  3.     synchronized (lock) {
  4.         try {
  5.             // 让当前线程休眠
  6.             lock.wait();
  7.         } catch (InterruptedException e) {
  8.             e.printStackTrace();
  9.         }
  10.     }
  11. }).start();
  12. synchronized (lock) {
  13.     lock.notify(); // 唤醒当前对象上一个休眠线程
  14.     // lock.notifyAll(); // 唤醒当前对象上所有休眠的线程
  15. }

需要注意的是 wait/notify/notifyAll 在使用时必须要配合 synchronized 一起使用，否则程序执行会报错。

方法4：Condition

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

  • await()：让当前线程进入等待状态，直到被通知（signal）或者被中断时才会继续执行。
  • awaitUninterruptibly()：让当前线程进入等待状态，直到被通知才会被唤醒，它对线程的中断通知不做响应。
  • await(long time, TimeUnit unit)：在 await() 方法的基础上添加了超时时间，如果过了超时时间还没有遇到唤醒方法则会自动唤醒并恢复执行。
  • awaitUntil(Date deadline)：让当前线程进入等待状态，如果没有遇到唤醒方法也会在设置的时间之后自动唤醒。
  • signal()：唤醒一个等待在 Condition 上的线程。
  • signalAll()：唤醒等待在 Condition 上所有的线程。

它的基本用法如下：

  1. import java.time.LocalDateTime;
  2. import java.util.concurrent.locks.Condition;
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5. public class ConditionExample {
  6.     public static void main(String[] args) throws InterruptedException {
  7.         // 创建锁
  8.         final Lock lock = new ReentrantLock();
  9.         // 创建 Condition
  10.         final Condition condition = lock.newCondition();
  11.         new Thread(() -> {
  12.             System.out.println("线程执行：" + LocalDateTime.now());
  13.             lock.lock(); // 得到锁
  14.             try {
  15.                 // 休眠线程
  16.                 condition.await();
  17.             } catch (InterruptedException e) {
  18.                 e.printStackTrace();
  19.             } finally {
  20.                 lock.unlock(); // 释放锁
  21.             }
  22.             System.out.println("线程结束：" + LocalDateTime.now());
  23.         }).start();
  24.         Thread.sleep(1000);
  25.         lock.lock(); // 得到锁
  26.         try {
  27.             // 唤醒线程
  28.             condition.signal();
  29.         } finally {
  30.             lock.unlock(); // 释放锁
  31.         }
  32.     }
  33. }

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

如下代码所示：

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

方法5：LockSupport

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

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

它的基础用法如下：

  1. Thread t1 = new Thread(() -> {
  3.     System.out.println("线程1休眠");
  5.     LockSupport.park(); // 休眠线程
  7.     System.out.println("线程1执行结束");
  9. }, "线程1");
  11. t1.start();
  14. Thread t2 = new Thread(() -> {
  16.     System.out.println("线程2休眠");
  18.     LockSupport.park(); // 休眠线程
  20.     System.out.println("线程2执行结束");
  22. }, "线程2");
  24. t2.start();
  27. Thread t3 = new Thread(() -> {
  29.     try {
  31.         Thread.sleep(1000);
  33.     } catch (InterruptedException e) {
  35.         e.printStackTrace();
  37.     }
  39.     System.out.println("唤醒线程1");
  41.     LockSupport.unpark(t1); // 唤醒线程1
  43. }, "线程3");
  45. t3.start();

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

778b320e71b1401cba10f910d7edd1ad.png

方法总结

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

线程睡眠的作用

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

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

线程睡眠的注意事项

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

1. InterruptedException异常

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

  1. Thread t = new Thread(new Runnable() {
  2.         @Override
  3.         public void run() {
  4.             try {
  5.                 Thread.sleep(3000);
  6.             } catch (InterruptedException e) {
  7.                 e.printStackTrace();
  8.             }
  9.         }
  10.     });
  12.     t.start();
  14.     // 主线程等待子线程执行完毕
  15.     try {
  16.         t.join();
  17.     } catch (InterruptedException e) {
  18.         e.printStackTrace();
  19.     }

2. 线程睡眠不会释放锁

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

  1. synchronized (obj) {
  2.         System.out.println("获取obj锁");
  3.         try {
  4.             Thread.sleep(5000);
  5.         } catch (InterruptedException e) {
  6.             e.printStackTrace();
  7.         }
  8.         System.out.println("释放obj锁");
  9.     }

3. 睡眠时间应尽量短

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

4. 时间单位要选对

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

  1. try {
  2.         TimeUnit.SECONDS.sleep(1);
  3.     } catch (InterruptedException e) {
  4.         e.printStackTrace();
  5.     }

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

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

线程睡眠的应用场景

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

1. 定时器和倒计时器

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

  1. for (int i = 10; i >= 0; i--) {
  2.         System.out.println("倒计时：" + i);
  3.         try {
  4.             Thread.sleep(1000);
  5.         } catch (InterruptedException e) {
  6.             e.printStackTrace();
  7.         }
  8.     }

2. 多线程并发控制

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

  1. Thread t1 = new Thread(new Runnable() {
  2.         @Override
  3.         public void run() {
  4.             synchronized (obj) {
  5.                 System.out.println("t1获取obj锁");
  6.                 try {
  7.                     Thread.sleep(5000);
  8.                 } catch (InterruptedException e) {
  9.                     e.printStackTrace();
  10.                 }
  11.                 System.out.println("t1释放obj锁");
  12.             }
  13.         }
  14.     });
  16.     Thread t2 = new Thread(new Runnable() {
  17.         @Override
  18.         public void run() {
  19.             try {
  20.                 Thread.sleep(1000);
  21.             } catch (InterruptedException e) {
  22.                 e.printStackTrace();
  23.             }
  25.             synchronized (obj) {
  26.                 System.out.println("t2获取obj锁");
  27.             }
  28.         }
  29.     });
  31.     t1.start();
  32.     t2.start();
  34.     // 主线程等待子线程执行完毕
  35.     try {
  36.         t1.join();
  37.         t2.join();
  38.     } catch (InterruptedException e) {
  39.         e.printStackTrace();
  40.     }

3. 提高程序的运行效率

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

  1. long start = System.currentTimeMillis();
  2.     loadImages();
  3.     long end = System.currentTimeMillis();
  4.     System.out.println("图片加载耗时：" + (end - start) + "ms");
  6.     private void loadImages() {
  7.         for (int i = 0; i < imageUrls.length; i++) {
  8.             loadSingleImage(imageUrls[i]);
  9.             try {
  10.                 Thread.sleep(500);
  11.             } catch (InterruptedException e) {
  12.                 e.printStackTrace();
  13.             }
  14.         }
  15.     }

总结：

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

发表评论

表情：
评论列表 （有 0 条评论，150人围观）

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

相关阅读

    相关 JAVA 线程池深入解析

    在开发中我们经常与会遇到需要在子线程中处理相关操作的问题，但是遇到大量线程的时候，每次都去创建一个线程是非常不合理的做法，这里我们就需要对线程作统一的管理。也就是线程池。

    蔚落蔚落/ 0 赞/ 374 阅读

    相关 Thread.sleep() 线程睡眠

    通俗的理解 ：        就是放在你想让线程休息的地方，比如你打印一些随机数的话，你想让它打印的速率慢一点，这个时候，你就可以在打印那个地方sleep()一下。 定义理

    系统管理员系统管理员/ 0 赞/ 208 阅读

    相关 Java线程池用法解析

    微信搜索：“二十同学” 公众号，欢迎关注一条不一样的成长之路 1、new Thread的弊端 执行一个异步任务你还只是如下new Thread吗？ new T

    小鱼儿小鱼儿/ 0 赞/ 418 阅读

    相关 Java的线程睡眠sleep

    一 点睛 如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过Thread类的静态方法sleep() 方法来实现。 当当前线程调用sleep()方法进入阻塞

    红太狼红太狼/ 0 赞/ 343 阅读