Java中wait与sleep的区别讲解(wait有参及无参区别)

目录
  • 1. wait() 与wait( long timeout ) 区别
  • 2. wait(0) 与 sleep(0)区别
  • 3. wait 和sleep 释放代码
  • 4. wait 与 sleep 区别
    • 相同点:
    • 不同点:

1. wait() 与wait( long timeout ) 区别

public class WaitDemo4 {
    public static void main(String[] args) {
        Object lock = new Object();
        Object lock2 = new Object();
        new Thread(() -> {
            System.out.println("线程1: 开始执行" + LocalDateTime.now());
            synchronized (lock) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1: 执行完成" + LocalDateTime.now());
            }
        },"无参wait线程").start();

        new Thread(() -> {
            System.out.println("线程2: 开始执行" + LocalDateTime.now());
            synchronized (lock2) {
                try {
                    lock2.wait(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2: 执行完成" + LocalDateTime.now());
            }
        },"有参wait线程").start();
    }
}

输出:
线程2: 开始执行2022-04-12T12:13:57.130
线程1: 开始执行2022-04-12T12:13:57.130
线程2: 执行完成2022-04-12T12:13:58.130

不同点:

1.wait( long timeout) :当线程超过了设置时间之后,自动恢复执行;而wait() 无线等待状态。

2. 使用无参的wait方法,线程会进入WAITING; 使用有参的wait方法,线程会进入TIMED_WAITING。

public class WaitDemo5 {
    public static void main(String[] args) {
        Object lock = new Object();
        Object lock2 = new Object();
        new Thread(() -> {
            synchronized (lock2) {
                System.out.println("线程2: 开始执行" + LocalDateTime.now());
                try {
                    lock2.wait(60 * 60 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2: 执行完成" + LocalDateTime.now());
            }
        },"有参wait线程").start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) {
                System.out.println("唤醒线程2");
                lock2.notify();
            }
        }).start();
    }
}
输出:
线程2: 开始执行2022-04-12T12:28:23.200
唤醒线程2
线程2: 执行完成2022-04-12T12:28:24.169
public class WaitDemo6 {
    public static void main(String[] args) {
        Object lock = new Object();

        new Thread(() -> {
            System.out.println("线程1: 开始执行" + LocalDateTime.now());
            synchronized (lock) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1: 执行完成" + LocalDateTime.now());
            }
        },"无参wait线程").start();

        new Thread(() -> {
            System.out.println("线程2: 开始执行" + LocalDateTime.now());
            synchronized (lock) {
                try {
                    lock.wait(60 * 60 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2: 执行完成" + LocalDateTime.now());
            }
        },"有参wait线程").start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock) {
                System.out.println("唤醒所有线程");
                lock.notifyAll();
            }
        }).start();
    }
}

输出:
线程1: 开始执行2022-04-12T12:34:34.317
线程2: 开始执行2022-04-12T12:34:34.317
唤醒所有线程
线程2: 执行完成2022-04-12T12:34:35.295
线程1: 执行完成2022-04-12T12:34:35.295

共同点:

1. 无论是有参的wait方法还是无参的wait方法,它都可以使用当前线程进入休眠状态。

2.无论是有参的wait方法还是无参的wait方法,它都可以使用notify / ontifyAll进行唤醒。

2. wait(0) 与 sleep(0)区别

public class WaitSleepDemo7 {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程1:开始执行");
                try {
                    lock.wait(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1:执行结束");
            }
        },"wait(0)");
        t1.start();

        Thread t2 = new Thread(() -> {
            System.out.println("线程2:开始执行");
            try {
                Thread.sleep(0);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2:执行结束");
        }, "sleep(0)");
        t2.start();
    }
}
输出:
线程1:开始执行
线程2:开始执行
线程2:执行结束

wait (0) : 无限期等待下去,相当于wait();

sleep(0) :相当于Thread.yeild() , 让出CPU执行权,重新调度,但是sleep(0) 会继续执行。

3. wait 和sleep 释放代码

wait 和 sleep 在有所的情况下的锁处理行为是完全不同的:

public class WaitSleepDemo8 {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Object lock2 = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程1:开始执行");
                try {
                    lock.wait(3 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1:结束执行");
            }
        }, "wait");
        t1.start();

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("线程2:开始执行");
                try {
                    Thread.sleep(3 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2:结束执行");
            }
        }, "sleep");
        t2.start();

        // 创建 2 个线程,先让线程休眠 1s 之后,尝试获取,看能不能获取到锁
        // 如果可以获取到锁,说明休眠时线程是释放锁的,而如果获取不到锁,说明是不释放锁
        Thread t3 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("尝试获取 wait 方法的锁");
            synchronized (lock) {
                System.out.println("成功获取 wait 的锁");
            }
        }, "wait2");
        t3.start();

        Thread t4 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(0);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("尝试获取 sleep 方法的锁");
            synchronized (lock2) {
                System.out.println("成功获取 sleep 的锁");
            }
        }, "sleep2");
        t4.start();

    }
}
输出:
线程1:开始执行
线程2:开始执行
尝试获取 sleep 方法的锁
尝试获取 wait 方法的锁
成功获取 wait 的锁
线程1:结束执行
线程2:结束执行
成功获取 sleep 的锁

wait方法(不管是有参还是无参)在执行的时候都会释放锁;而sleep 方法不会释放锁。

4. wait 与 sleep 区别

相同点:

1. 都是可以让线程进入休眠

2. 都可以响应Interrupt(中断)请求

不同点:

1. wait必须配合synchronized一起使用;而sleep不需要。

2. wait 属于Object(对象)的方法;而sleep属于Thread(线程)的方法。

3. sleep 不释放锁;而wait释放锁。

4. sleep 必须要传递一个数值类型的参数;而wait可以不传参。

5. sleep 让线程进入到TIMED_WAITING状态;而无参的wait方法让线程进入了WAITING状态。

6. 一般情况下,sleep只能等待超时时间之后再回复执行;而wait可以接受notify / notifiAll之后就绪执行。

(MS):

1.为什么 wait 释放锁⽽ sleep 不释放锁?

【JVM 强制语法检查,wait ⽅法默认等待⽆期限】

2.为什么 wait 要放在 Object 中?

【wait 使⽤要加锁,也就是要操作锁,锁是针对对象级别的⽽⾮线程级别的,线程和对象是⼀对多,所以 wait 最便利的⽅式是放在 Object 中】

到此这篇关于Java中wait与sleep的区别讲解(wait有参及无参区别)的文章就介绍到这了,更多相关java wait与sleep内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • java sleep()和wait()的区别点总结

    1.区别说明 wait()是Object的方法,sleep()是Thread的方法. wait()必须采用同步方法,不需要sleep()方法. 线程在同步方法中执行sleep()方法,不释放monitor锁,wait()方法释放monitor锁. 短暂休眠后,sleep()方法会主动退出阻塞,而wait()方法需要在没有指定wait时间的情况下被其他线程中断才能退出阻塞. 2.实例 import java.text.SimpleDateFormat; import java.util.Date;

  • Java线程阻塞方法sleep()与wait()的全面讲解

    一.前期基础知识储备 sleep()和wait()方法都是Java中造成线程阻塞的方法.感兴趣的读者可以参见笔者之前的文章<Java中什么方法导致线程阻塞>,里面详细讲述了为什么Java要造成线程阻塞和Java中造成线程阻塞的几种方法. (1)线程的生命周期 这是笔者在谷歌图片中找到的一张简单描述线程生命周期的图片,可以看到,一个线程正常的生命周期中会经历"创建""就绪""运行""阻塞""运行"

  • 详解Java中wait和sleep的区别

    1.概述 在这篇简短的文章中,我们将看一下核心Java 中的标准sleep()和wait()方法,并了解它们之间的差异和相似之处. 2. wait和sleep之间的一般差异 简单地说,wait()是一个用于线程同步的实例方法. 它可以在任何对象上调用,因为它在java.lang.Object上定义,但它只能从synchronized块中调用.它释放对象的锁定,以便另一个线程可以跳入并获取锁. 另一方面,Thread.sleep()是一个可以从任何上下文调用的静态方法.Thread.sleep()

  • 详解Java中的sleep()和wait()的区别

    详解Java中的sleep()和wait()的区别 对于sleep()方法,我们首先要知道该方法是属于Thread类中的.而wait()方法,则是属于Object类中的. sleep()方法导致了程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动恢复运行状态. 在调用sleep()方法的过程中,线程不会释放对象锁. 而当调用wait()方法的时候,线程会放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象调用notify()方法后本线程才进入对象

  • Java中wait与sleep的区别讲解(wait有参及无参区别)

    目录 1. wait() 与wait( long timeout ) 区别 2. wait(0) 与 sleep(0)区别 3. wait 和sleep 释放代码 4. wait 与 sleep 区别 相同点: 不同点: 1. wait() 与wait( long timeout ) 区别 public class WaitDemo4 { public static void main(String[] args) { Object lock = new Object(); Object loc

  • java 中动态代理机制的实例讲解

    java 中动态代理机制的实例讲解 在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的我们的功能,我们更需要学习的是其底层是怎么样的一个原理,而AOP的原理就是java的动态代理机制,所以本篇随笔就是对java的动态机制进行一个回顾. 在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface)

  • 基于Java中UDP的广播形式(实例讲解)

    UDP---用户数据报协议,是一个简单的面向数据报的运输层协议.UDP不提供可靠性,它只是把应用程序传给IP层的数据报发送出去,但是并不能保证它们能到达目的地 ,也不能保证数据包到达的顺序.由于UDP在传输数据报前不用在客户和服务器之间建立一个连接,且没有超时重发等机制,故而传输速度很快. 在Java中UDP的实现: * UDP: * 客户端: * 1.创建用于UDP通信的socket对象---DatagramSocket(用于UDP数据的发送和接收)---数据报套接字 * 2.准备数据,封装包

  • java中list的用法和实例讲解

    目录: list中添加,获取,删除元素: list中是否包含某个元素: list中根据索引将元素数值改变(替换): list中查看(判断)元素的索引: 根据元素索引位置进行的判断: 利用list中索引位置重新生成一个新的list(截取集合): 对比两个list中的所有元素: 判断list是否为空: 返回Iterator集合对象: 将集合转换为字符串: 将集合转换为数组: 集合类型转换: 去重复: 备注:内容中代码具有关联性. 1.list中添加,获取,删除元素: 添加方法是:.add(e): 获

  • java中使用map排序的实例讲解

    对列表进行排序也是我们经常遇到的问题,这里缩小一下范围,使用map来对列表排序.相信大家都有过TreeMap排序的经历,不过Map.Entry能按值进行排序,在用法上略胜一筹.下面我们会对这两种map排序的方法分别进行介绍,着重讲解Map.Entry排序的方法. 1.Map.Entry方法 把Map.Entry放进list,再用Comparator对list进行排序 List list = new ArrayList(map.entrySet()); Collections.sort(list,

  • Java中序列化和反序列化的完整讲解

    目录 一.序列化 二.序列化和反序列化的应用 三.序列化和反序列化地实现 3.1.JDK类库提供的序列化API 3.2.序列化要求 3.3.实现java序列化和反序列化的三种方法 四.CustomerForm 类序列化和反序列化演示 五.Externalizable接口实现序列化与反序列化 5.1.Externalizable 的不同点 5.2.CustomerForm 实现类 Externalizable 5.3.Externalizable 实现序列化和反序列化 总结 一.序列化 1.1.S

  • Java中控制流程语句的深入讲解

    目录 前言 if-then if-then-else switch 使用 String while do-while for break continue return 总结 前言 流程控制语句是用来控制程序中各语句执行顺序的语句,可以把语句组合成能完成一定功能的小逻辑模块. 控制语句分为三类:顺序.选择和循环. 顺序结构:代表"先执行a,再执行b"的逻辑. 选择结构:代表"如果-,则-"的逻辑. 循环结构:代表"如果-,则重复执行-"的逻辑.

  • Java中I/O输入输出的深入讲解

    目录 前言 一.流概述 二.输入/输出流 1.输入流 2.输出流 三.File类 1.文件的创建与删除 1.File(String pathname) 2.File(String parent,String child) 3.File(File f,String child) 2.获取文件信息 四.文件输入/输出流 1.FillInputStream与FileOutputStream类 2.FileReader和FileWriter类 五.带缓存的输入/输出流 1.BufferedInputSt

  • 基于java中反射的总结分析

    刚开始学习java的时候真的很难理解反射到底是个什么东西 一些书籍,哪怕是很经典的书籍都解释的让人感觉懵懵的,或许的确是我太笨 况且,网上说在将来学习框架的时候需要经常应用到反射机制,这样一来总让人心里有些不安 就方才偶然又把讲解反射的章节和视频看了一点,觉得能理解一些了 现在决定一鼓作气,边看边写,顺便把一些主要的内容和操作都记载到这里 我想,对于我这么一个笨笨的人来说,学习的最好方法也许就是不断重复 遇到不懂的知识就停下来把以往的重新学一遍,虽然浪费了很多时间,但对我也有些效果 我的理解是:

  • Java中map内部存储方式解析

    Map,即映射,也称为 键值对,有一个 Key, 一个 Value . 比如 Groovy 语言中,  def  map = ['name' : 'liudehua', 'age' : 50 ] ,则 map[ 'name' ]  的值是 'liudehua'. 那么 Map 内部存储是怎么实现的呢?   下面慢慢讲解. 一. 使用 拉链式存储 这个以 Java 中的 HashMap 为例进行讲解.   HashMap 的内部有个数组 Entry[]  table, 这个数组就是存放数据的. E

随机推荐