java中的wait和sleep

最新推荐文章于 2024-09-18 16:02:57 发布
最新推荐文章于 2024-09-18 16:02:57 发布
阅读量2.3k 收藏 2
点赞数 1
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61139806/article/details/133921207
版权

线程的状态

Java中线程的状态分为 6 种：

  1. 初始(NEW)：新建了一个线程对象，但是还没调用start() 方法
  2. 运行(RUNNABLE)：Java 线程中将就绪（ready）和运行中（running）两种状态统称为“运行”。线程对象在创建之后，其他线程(比如 main 线程)调用了该对象的 start() 方法，该状态的线程位于可变线程池中，等待被线程调度选中，获取CPU 的使用权，此时处于就绪状态(ready)。就绪状态的线程在获得 CPU时间片后变为运行状态(running)。
  3. 阻塞(BLOCKED)：表示线程阻塞与锁。
  4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定的动作(通知或者中断)。
  5. 超时等待(TIMED_WAITING)：该状态不同于 WAITING，它可以在指定的时间后自行返回。
  6. 终止(TERMINATED)：表示该线程已经执行完毕。

wait

使用场景

获取到某个线程之后，发现当前并不需要使用该线程，则可以调用wait() 方法，使其进入等待过程。

等到某个时刻，满足条件之后，则可以使用notify() 或者 notifyAll() 方法来唤醒这个线程。

使用条件

对于已经获取到锁的线程才可以调用锁的wait(),notify(）方法，否则会抛出IllegalMonitorStateException 异常。

比如下面的代码，A获得了锁之后，主动调用 wait() 方法释放锁和CPU资源，然后就进入了阻塞状态。

主线程在没有获得锁的情况之下，直接调用notify() 方法会抛出异常。

public class WaitTest {

    public static void main(String[] args) {
        Object lock = new Object();
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                System.out.println("获取到锁");
                try {
                    System.out.println("休眠一会");
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("调用wait");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("被唤醒");
            }
        }, "A");
        threadA.start();

        lock.notify();
    }
}

输出结果：

现在我们创建一个线程B，抢占锁后，再调用 notify() 方法

public class WaitTest {

    public static void main(String[] args) {
        Object lock = new Object();
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                System.out.println("A 获取到锁");
                try {
                    System.out.println("休眠一会");
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("调用wait");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("A 被唤醒");
            }
        }, "A");
        threadA.start();

        Thread threadB = new Thread(() -> {
            synchronized (lock) {
                System.out.println("B 获取了锁");

                System.out.println("B 唤醒 A");
                lock.notify();
            }
        },"B");
        threadB.start();
    }
}

线程状态变化

首先我们需要知道，线程正常运行时的状态是 RUNNABLE，调用 wait() 方法后，变为 WAITING 状态。

举例说明：

public class WaitTest {

    public static void main(String[] args) {
        Object lock = new Object();
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                System.out.println("A 获取到锁");
                try {
                    System.out.println("休眠一会");
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("调用wait");
                try {
                    System.out.println("调用wait前的线程状态："+Thread.currentThread().getState());
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("A 被唤醒");
            }
        }, "A");
        threadA.start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("调用wait后的线程状态："+threadA.getState());

    }
}

输出结果：

提问：主动 wait 的线程，被唤醒之后，它的状态一定是从 WAITING 变成 RUNNABLE 吗？

我们再做一个测试：A线程wait，2秒后，启动B线程，B线程去唤醒A线程。记录下唤醒前后的状态。

public class WaitTest {

    public static void main(String[] args) {
        Object lock = new Object();
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                System.out.println("A 获取到锁");
                try {
                    System.out.println("休眠一会");
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("调用wait");
                try {
                    System.out.println("调用wait前的线程状态："+Thread.currentThread().getState());
                    lock.wait();
                    System.out.println("调用notify后的线程状态："+Thread.currentThread().getState());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("A 被唤醒");
            }
        }, "A");
        threadA.start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread threadB = new Thread(() -> {
           synchronized (lock) {
               System.out.println("B 获取到锁");
               System.out.println("叫醒A前，A的状态："+threadA.getState());
               System.out.println("叫醒A");
               lock.notify();
           }
        },"B");
        threadB.start();
    }
}

输出结果：

上面的例子与我们的猜测是一致的。

但是，这段代码并不严谨，上述代码的 B线程在调用了 notify() 方法之后，立即释放了锁，但假如 B线程调用 notify() 后，还有很多任务没有完成，不立即释放锁，A线程的状态又会有什么变化？

修改后的代码：

public class WaitTest {

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                System.out.println("A 获取到锁");
                try {
                    System.out.println("休眠一会");
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("调用wait");
                try {
                    System.out.println("调用wait前的线程状态："+Thread.currentThread().getState());
                    lock.wait();
                    System.out.println("调用notify后的线程状态："+Thread.currentThread().getState());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("A 被唤醒");
            }
        }, "A");
        threadA.start();

        TimeUnit.SECONDS.sleep(2);

        Thread threadB = new Thread(() -> {
           synchronized (lock) {
               System.out.println("B 获取到锁");
               System.out.println("叫醒A前，A的状态："+threadA.getState());
               System.out.println("叫醒A");
               lock.notify();
               System.out.println("发现还有很多事要做，先不释放锁");
               System.out.println("B 在做其他事的时候，A 的状态："+threadA.getState());
               try {
                   TimeUnit.SECONDS.sleep(2);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("B 的事情都做完了");
           }
        },"B");
        threadB.start();
    }
}

输出结果：

通过观察我们发现，A 的状态并没有立刻变成 RUNNALBE，而是 BLOCKED，等到 B线程任务处理完释放锁之后，A 的状态才变成 RUNNALBE。

也就是说，B调用完 notify() 方法后，并不会立刻把线程的控制权交出去，A 被唤醒后，也不会立即将状态变成 RUNNABLE，而是先变成 BLOCKED，然后参与锁竞争，竞争成功重新获得锁之后，再向下执行。

Java中，每一个对象都有一个对应的 Monitor 锁，Monitor维护着 EntrySet 和 WaitSet。线程阻塞时，对象会被放入到 EntrySet 中，对应的状态是 BLOCKED。线程调用wait方法后，会被加入到WaitSet中，对应的状态是WAITING、TIMED_WAITIING。

上面我们分析过，线程“被唤醒”和“获得锁”是两个过程，被唤醒的线程需要重新参与锁竞争。

这么理解的话，那么线程应该是从 WaitSet 中苏醒后，又被加入到 EntrySet 队列。

有限等待

wait() 方法可以传入一个时间参数，是一种自动唤醒机制：在指定的时间内，如果没有其他线程唤醒自己，则主动唤醒自己。传 0 或者不传，则表示永久等待。

public class WaitTest {

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                System.out.println("A 获取到锁");
                try {
                    System.out.println("休眠一会");
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("调用wait");
                try {
                    System.out.println("调用wait前的线程状态："+Thread.currentThread().getState());
                    System.out.println("当前时间："+System.currentTimeMillis());
                    lock.wait(1000);
                    System.out.println("调用notify后的线程状态："+Thread.currentThread().getState());
                    System.out.println("当前时间："+System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("A 被唤醒");
            }
        }, "A");
        threadA.start();

    }
}

输出结果：

这只是一种情况，如果 A 被唤醒后，继续参加锁的竞争，假设 A 在wait(t) 的过程中，有其他线程抢占了线程，A还能继续执行吗？

以下是代码示例：

public class WaitTest {

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                System.out.println("A 获取到锁");
                try {
                    System.out.println("休眠一会");
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("调用wait");
                try {
                    System.out.println("调用wait前的线程状态："+Thread.currentThread().getState());
                    System.out.println("当前时间："+System.currentTimeMillis());
                    lock.wait(100);
                    System.out.println("调用notify后的线程状态："+Thread.currentThread().getState());
                    System.out.println("当前时间："+System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("A 被唤醒");
            }
        }, "A");
        threadA.start();

        Thread threadB = new Thread(() -> {
           synchronized (lock) {
               try {
                   TimeUnit.SECONDS.sleep(2);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("A 的状态："+threadA.getState());
               while (true) {

               }
           }
        },"B");
        threadB.start();
    }
}

输出结果：

即使 1000ms 过了，A 也不能继续执行，因为 A 只是被唤醒了，但是并没有成功获得锁，所以会进入 BLOCKED 状态。

sleep

Java中的线程休眠可以使用 Thread 类的静态方法 sleep()实现，该方法可以让当前线程暂停执行一段时间，以等待其他线程完成某些操作，或者为了节省系统资源而暂停线程执行。

代码示例：

public class SleepThreadExample {
    public static void main(String[] args) {
        System.out.println("线程开始执行");
        try {
            Thread.sleep(5000); // 休眠5秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程结束执行");
    }
}

在上面的代码中，我们使用sleep() 方法让线程休眠5 秒，然后再继续执行。如果在休眠期间线程被终端，就会抛出 InterruptedException异常。

需要注意的是，sleep() 方法会暂停当前线程的执行，因此如果在主线程中调用该方法，就会导致整个程序暂停执行，直到指定的时间到达。因此，我们应该避免在主线程中过渡使用sleep()方法，以免影响程序的响应性和用户体验。

sleep和wait的异同点

相同点

  1. 都可以使线程堵塞
  2. 都可以响应中断

不同点

  1. wait、notify方法必须写在同步方法中，是为了防止死锁和永久等待，使线程更安全，而sleep方法不需要有这个限制。
  2. wait方法调用后会释放锁，sleep方法调用后不会释放锁。
  3. sleep方法必须要指定时间参数，wait方法可以指定时间参数，但不是必需的
  4. 两个方法所属类不同，sleep方法属于Thread类；wait属于Object类中，放在Object类中是因为Java中每个类都可以是一把锁。
我不是小明同学
关注
java中wait和sleep的区别_java wait和sleep的区别是什么
weixin_31956641的博客
02-12 4986
所以sleep()和wait()方法的最大区别是：·sleep()睡眠时，保持对象锁，仍然占有该锁；·而wait()睡眠时，释放对象锁。·但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException(但不建议使用该方法)。/*** Created by jiankunking on 2018/4/5.*/publ...
Java中sleep()与wait()的区别总结
08-30
因为最近学习时正好碰到这两个方法，就查阅相关资料，并通过程序实现，进行区别总结一下，所以下面这篇文章主要给大家总结介绍了关于Java中sleep()与wait()区别的相关资料，需要的朋友可以参考，下面来一起看看吧。
Java 中的 sleep、wait、join 怎么理解
最新发布
pige666的博客
09-18 488
在 Java 中，sleep()、wait() 和 join() 都是与线程同步和控制相关的常用方法，它们各自有不同的功能和使用场景。
java中的sleep()和wait()的区别
abxlep7702的博客
12-10 128
对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。 sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。 在调用sleep()方法的过程中，线程不会释放对象锁。 而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待...
Java多线程中Sleep与Wait的区别
AlexWang
11-06 6907
Java中的多线程是一种抢占式的机制，而不是分时机制。抢占式的机制是有多个线程处于可运行状态，但是只有一个线程在运行。 共同点： 1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。 2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。    如果线程A希望
Java之sleep和wait
wyg1973017714的博客
05-18 5537
Java之sleep和wait sleep和wait方法都是native关键字修饰的方法，这说明这两个方法是原生函数，也就是由C/C++实现的，那么我们就暂时不关心它的具体实现了。 sleep方法是Thread类中的方法，而wait方法是Object中的方法，那么我们首先看看wait方法。 Object#wait() 从Object源码中，我们可以发现，wait有三个重载方法，分别是无参的wait方法，带有long和int类型参数的的wait方法，以及带有long类型参数的方法。其实前两个方法最终都是调用了
【Java】Sleep和Wait的区别
double222222的博客
03-05 1947
在实际编程中，我们需要根据具体的需求和场景来选择合适的机制，以实现更好的系统性能和用户体验。则是一个线程或进程等待另一个线程或进程完成某项操作的操作。它通常用于实现线程或进程之间的同步。如果一个线程或进程长时间等待另一个线程或进程完成，那么它可能会占用系统资源而无法执行其他任务。在这段时间内，线程或进程不会执行任何代码，而是将CPU的控制权交还给操作系统，让其他线程或进程有机会执行。这些函数会阻塞当前线程或进程的执行，直到指定的时间过去。时，需要谨慎考虑线程或进程之间的同步策略，以避免出现性能瓶颈。
详解Java中wait和sleep的区别
08-26
"详解Java中wait和sleep的区别" Java中wait和sleep的区别是Java多线程编程中一个重要的概念。这两个方法都可以用来暂停当前线程的执行，但是它们之间有着根本的区别。 首先，wait（）是一个用于线程同步的实例方法...
在java中wait和sleep方法的不同
渡安H的博客
01-17 676
最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。 在Java中线程的状态一共被分成6种： 初始态： 创建一个Thread对象，但还未调用start()启动线程时，线程处于初始态。 运行态：在Java中，运行态包括就绪态和运行态。 就绪态：该状态下的线程已经获得执行所需的所有资源，只要CPU分配执行权就能运行...
Java中wait()和notify()方法的使用，wait()和sleep()的区别？
十三月的博客
08-28 120
在Java中，wait()和notify()方法用于线程间的协调和通信。这些方法是多线程编程中非常重要的工具，它们属于Object类，因此每个Java对象都可以调用这些方法。它们通常与同步机制一起使用，以确保线程之间的安全通信。
JAVA—sleep（）和wait（）的区别
热门推荐
clam_clam的专栏
09-23 4万+
JAVA—sleep（）和wait（）的区别 sleep()和wait()的区别 Java中的多线程是一种抢占式的机制而不是分时机制。线程主要有以下几种状态：可运行，运行，阻塞，死亡。抢占式机制指的是有多个线程处于可运行状态，但是只有一个线程在运行
Java中wait和sleep区别
stormkai的专栏
03-08 1855
Java中wait和sleep区别 sleep属于Thread类中的static方法；wait属于Object类的方法 sleep时线程状态进入TIMED_WAITING（计时等待），时间到了后自动被唤醒；wait时线程状态进入WAITING（等待），需要手动唤醒 sleep方法在线程持有锁时候执行，不会释放锁资源；wait方法执行后会释放锁资源 sleep可以在持有锁或者不持有锁时执行；wait方法必须在持有锁时执行
java中的wait和sleep_Java中的wait和sleep
weixin_39621669的博客
02-25 161
sleep()和wait()首先，Java中的多线程是一种抢占式的机制，而不是分时机制。抢占式的机制是有多个线程处于可运行状态，但是只有一个线程在运行。这种机制决定了，对于同一对象的多线程访问，必须考虑同步的问题，synchronize的意义在这。几个区别：sleep是Thread类的方法，用于线程自身的控制；wait是Object类的方法，用于线程之间的控制，配套的方法是Object·的noti...
java wati_java中wait和sleep的区别
weixin_33969103的博客
02-13 157
java中wait和sleep的区别在本篇文章中，我们将会讨论一下java中wait()和sleep()方法的区别。并讨论一下怎么使用这两个方法。Wait和sleep的区别wait() 是Object中定义的native方法：public final native void wait(long timeout) throws InterruptedException;所以每一个类的实例都可以调用这...
Java中sleep()与wait()区别
superballball的博客
10-11 100
1、每个对象都有一个锁来控制同步访问，Synchronized关键字可以和对象的锁交互，来实现同步方法或同步块。sleep()方法正在执行的线程主动让出CPU（然后CPU就可以去执行其他任务），在sleep指定时间后CPU再回到该线程继续往下执行(注意：sleep方法只让出了CPU，而并不会释放同步资源锁！！！)；wait()方法则是指当前线程让自己暂时退让出同步资源锁，以便其他正在等待该资源的线...
java中wait和sleep_详解Java中wait和sleep的区别
weixin_29021195的博客
02-21 311
1.概述在这篇简短的文章中，我们将看一下核心Java 中的标准sleep()和wait()方法，并了解它们之间的差异和相似之处。2. wait和sleep之间的一般差异简单地说，wait()是一个用于线程同步的实例方法。它可以在任何对象上调用，因为它在java.lang.Object上定义，但它只能从synchronized块中调用。它释放对象的锁定，以便另一个线程可以跳入并获取锁。另一方面，Th...
java中的wait()和sleep()
qq_36327266的博客
03-03 703
前言 本篇文章记录了java多线程中wait()、sleep()的使用方式和两者之间的区别。 一、线程的五种状态 线程的状态有五种，分别是：初始状态、就绪状态、运行状态、阻塞状态、死亡状态。它们之间的关系如图所示： 二、wait() wait()是属于Object类的一个方法，所以任何对象都可以使用这个方法，它的作用是使当前线程由运行状态进入阻塞状态，当被唤醒或经过规定的时间后再进入就绪状态。这个方法必须在有锁的代码块中使用，要不然的话会出现IllegalMonitorStateExce.
java 中 sleep 和 wait
luyao3038的博客
08-31 619
一起来聊聊 java 中 sleep 和 wait - 知乎java中sleep的用法是什么-java教程-PHP中文网
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值