关于java:面试突击40线程休眠的方法有几种

30次阅读

共计 3882 个字符,预计需要花费 10 分钟才能阅读完成。

在 Java 中,让线程休眠的办法有很多,这些办法大抵能够分为两类,一类是设置工夫,在一段时间后主动唤醒,而另一个类是提供了一对休眠和唤醒的办法,在线程休眠之后,能够在任意工夫对线程进行唤醒。

PS:休眠是指让某个线程暂停执行(进入期待状态),唤醒指的是让某个暂停的线程继续执行。

线程休眠的办法有以下 5 个:

  1. Thread.sleep
  2. TimeUnit
  3. wait
  4. Condition
  5. LockSupport

其中 sleep 和 TimeUnit 是让线程休眠一段时间后主动唤醒,而 wait、Condition、LockSupport 提供了一对休眠和唤醒线程的办法,能够实现任意时刻唤醒某个线程。

办法 1:Thread.sleep

Thread.sleep 办法来自于 Thread 类,它是一个 native 本地办法,其实现源码如下:

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

Thread.sleep 办法须要传递一个 long 类型的毫秒数,示意 n 毫秒之后主动唤醒 ,它的根底用法如下:

Thread t1 = new Thread() {
    @Override
    public void run() {System.out.println("线程执行:" + LocalDateTime.now());
        try {Thread.sleep(1000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        System.out.println("线程完结:" + LocalDateTime.now());
    }
};
t1.start();

以上程序的执行后果如下图所示:

办法 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();

以上程序的执行后果如下图所示:

当咱们查看 TimeUnit 源码时就会发现,它的底层是基于 Thread.sleep 办法实现的,其实现源码如下:

办法 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();

以上程序的执行后果如下图所示:

总结

Thread.sleep 和 TimeUnit 是让线程休眠并在一段时间后主动唤醒,而 wait、Condition、LockSupport 提供了休眠和唤醒线程的办法,其中 Condition 为 wait 办法的升级版,而 LockSupport 是更底层的让线程休眠和唤醒的办法,它能够实现唤醒某个指定的线程,这是其它办法所不具备的(性能)。

是非审之于己,毁誉听之于人,得失安之于数。

公众号:Java 面试真题解析

面试合集:https://gitee.com/mydb/interview

正文完
 0