本文主要介绍了Java线程睡眠的五种方法，即Thread.sleep、TimeUnit、wait、Condition和LockSupport。以下文章将详细讲解这五种方法，有需要的可以参考。
目录
方法1: thread.sleep方法2: timeunit方法3: wait方法4: condition方法5: locksupport summary前言：
在Java中，有很多方法可以让线程休眠。这些方法大致可以分为两类。一类是设置时间，一定时间后自动唤醒，另一类提供一对睡眠和唤醒方式。线程休眠后，可以随时唤醒。
PS:休眠是指让一个线程暂停执行(进入等待状态)，唤醒是指让一个暂停的线程继续执行。
线程休眠的方法有以下 5 个：
thread . sleeptimeunitwaitconditionlocksupport
其中sleep和TimeUnit是线程休眠一段时间后自动唤醒线程的方法，而wait、Condition和LockSupport提供了一对休眠和唤醒线程的方法，可以随时唤醒线程。
方法1：Thread.sleep
Thread.sleep 方法来自于 Thread 类，它是一个 native 本地方法，其实现源码如下：
public static native void sleep(long millis)抛出InterruptedException
Thread.sleep 方法需要传递一个 long 类型的毫秒数，表示 n 毫秒之后自动唤醒,它的基础用法如下：
线程t1=新线程(){
@覆盖
公共无效运行(){
System.out.println('线程执行：' local datetime . now())；
尝试{
thread . sleep(1000)；
} catch (InterruptedException e) {
e . printstacktrace()；
}
System.out.println('线程结束：' local datetime . now())；
}
};
t1 . start()；
以上程序的执行结果如下图所示：
方法2：TimeUnit
因为sleep方法要传递一个毫秒类型的参数，所以设置一个比较大的时间，比如1小时或者1天，比较麻烦。这时候我们可以用TimeUnit代替sleep方法来睡眠。TimeUnit 的功能和 sleep 一样，让线程休眠 N 个单位时间之后自动唤醒,它的基础用法如下：
线程t1=新线程(){
@覆盖
公共无效运行(){
System.out.println('线程执行：' local datetime . now())；
尝试{
时间单位。seconds . sleep；//睡眠1s
//时间单位。days . sleep(1)；//睡眠1天
} catch (InterruptedException e) {
e . printstacktrace()；
}
System.out.println('线程结束：' local datetime . now())；
}
};
t1 . start()；
以上程序的执行结果如下图所示：
当我们查看 TimeUnit 源码时就会发现，它的底层是基于 Thread.sleep 方法实现的，其实现源码如下：
方法3：wait
等待/通知/通知都来自对象类其中：。
wait() / wait(long timeout)：表示让当前线程休眠。notify()：唤醒当前对象上的休眠线程。notifyAll()：唤醒当前对象上所有休眠的线程。
wait()方法意味着当前线程将无限期等待，直到遇到notify/notifyAll方法，wait(长超时)意味着接收到长超时。如果没有遇到notify/notifyAll，它会在很长的毫秒后自动唤醒，如果遇到notify/notifyAll方法，它会立即唤醒。其基本用法如下：
对象锁=新对象()；
新线程(()- {
同步(锁定){
尝试{
//让当前线程休眠
lock . wait()；
} catch (InterruptedException e) {
e . printstacktrace()；
}
}
}).start()；
同步(锁定){
lock . notify()；//唤醒当前对象上的休眠线程
//lock . notifyall()；//唤醒当前对象上所有休眠的线程
}
需要注意的是，wait/notify/notifyAll必须和synchronized一起使用，否则程序执行会报错。
方法4：Condition
Condition作为wait的升级版，提供了以下常用方法：
await()：让当前线程进入等待状态，直到有信号或中断才会继续执行。awaitUninterruptibly()：将当前线程置于等待状态，直到收到通知才会唤醒。它不响应线程的中断通知。await(long time, TimeUnit unit):在await()方法的基础上增加了超时。如果超时后不满足唤醒方法，它将自动唤醒并恢复执行。awaitUntil(Date deadline)：让当前线程进入等待状态，在设定的时间后，如果没有遇到唤醒方法，会自动唤醒。signal()：唤醒等待该条件的线程。signalAll()：唤醒所有等待该条件的线程。
它的基本用法如下：
导入Java . time . local datetime；
导入Java . util . concurrent . locks . condition；
导入Java . util . concurrent . locks . lock；
导入Java . util . concurrent . locks . reentrant lock；
公共类条件示例{
公共静态void main(String[] args)引发InterruptedException {
//创建锁
final Lock Lock=new reentrant Lock()；
//创建一个条件
最终条件Condition=lock . new Condition()；
新线程(()- {
System.out.println('线程执行：' local datetime . now())；
lock . lock()；//获取锁
尝试{
//睡眠线程
condition . await()；
} catch (InterruptedException e) {
e . printstacktrace()；
}最后{
lock . unlock()；//释放锁定
}
System.out.println('线程结束：' local datetime . now())；
}).start()；
thread . sleep(1000)；
lock . lock()；//获取锁
尝试{
//唤醒线程
condition . signal()；
}最后{
lock . unlock()；//释放锁定
}
}
}
与wait方法相比，Condition对象更加灵活，因为它可以在一个锁上定义多个Condition对象以供使用。
如下代码所示：
//创建锁
final Lock Lock=new reentrant Lock()；
//创建条件1
最终条件Condition=lock . new Condition()；
//创建条件2
最终条件Condition 2=lock . new Condition()；
//.
方法5：LockSupport
锁是下层操作线程睡眠和唤醒的对象，它提供了两个常用的方法：。
LockSupport.park()：休眠当前线程。LockSupport.unpark(Thread thread)：唤醒指定的线程。
它的基础用法如下：
线程t1=新线程(()- {
System.out.println('线程1休眠')；
lock support . park()；//睡眠线程
System.out.println(“线程1执行结束”)；
}，‘线程1’)；
t1 . start()；
线程t2=新线程(()- {
System.out.println('线程2处于休眠状态')；
lock support . park()；//睡眠线程
System.out.println(“线程2执行结束”)；
}、‘线程2’)；
T2 . start()；
线程t3=新线程(()- {
尝试{
thread . sleep(1000)；
} catch (InterruptedException e) {
e . printstacktrace()；
}
System.out.println('唤醒线程1 ')；
lock support . un park(t1)；//唤醒线程1
}、‘线程3’)；
T3 . start()；
以上程序的执行结果如下图所示：
总结
Thread.sleep和TimeUnit是让线程休眠并在一段时间后自动唤醒的方法，而wait、Condition和LockSupport提供了休眠和唤醒线程的方法，其中Condition是wait方法的升级版，而LockSupport是休眠和唤醒线程的低级方法，可以唤醒指定的线程，这是其他方法所不具备的(功能)。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。