/*** wait使用*/
public class WaitDemo {public static void main(String[] args) {Object lock = new Object();Thread t1 = new Thread(() -> {System.out.println("线程1开始执行");try {synchronized (lock) {System.out.println("线程1调用wait方法....");//无限期等待状态lock.wait();}} catch (InterruptedException e) {e.printStackTrace();}System.out.println("线程1执行完成");},"线程1");t1.start();}
}

import java.util.concurrent.TimeUnit;public class WaitSleepDemo7 {public static void main(String[] args) throws InterruptedException {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:结束执行");}System.out.println("线程1:终止执行");},"wait0");t1.start();TimeUnit.SECONDS.sleep(1);System.out.println("执行线程1的终止方法");t1.interrupt();}
}

1.1.3.wait() VS wait(long timeout)

1-不同点：wait(long timeout)：当线程超过了设置的时间之后，自动恢复执行；而wait()：无限等待状态。（0表示无限等待状态）

2-不同点：wait(long timeout)：线程会进入WAITING状态；而wait()：线程会进入TIMED_WAITING状态。

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

3-共同点：无论是wait(long timeout)还是wait()，都会使当前线程进入休眠状态。

4-共同点：无论是wait(long timeout)还是wait()，都能使用notify/notifyAll进行唤醒。

import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;public class WaitDemo6 {public static void main(String[] args) {Object lock = new Object();new Thread(() -> {System.out.println("线程1:开始执行");synchronized (lock){try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("线程1:执行完成");}},"无参wait线程").start();new Thread(() -> {synchronized (lock){System.out.println("线程2:开始执行 |" + LocalDateTime.now());try {lock.wait(60 * 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.1.4.为什么wait要放在Object中？

wait 使用要加锁，也就是要操作锁，锁是针对对象级别的而非线程级别的，线程和对象是⼀对多，所以 wait 最便利的方式是放在 Object 中。

wait(num)和sleep(num)：当num>0时，二者执行效果一样。

--->PS：wait(0) 和 sleep(0) 的区别

1. wait(0) 表示无期限地等待，直到有线程唤醒它为止。
2. Thread.sleep(0) 调用后会让出CPU执行权，让线程稍做休眠，然后重新调度，重新触发一次 CPU 竞争，不管是否竞争到CPU执行权，都会继续执行，直到执行结束。（类似于Thread.yield()）

/*** wait(0)和sleep(0)*/
public class WaitSleepDemo7 {public static void main(String[] args) throws InterruptedException {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();}
}

--->PS：wait 和 sleep 释放锁行为的区别

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

1. wait方法（不管是有参还是无参）在执行时都会释放锁。
2. sleep方法不会释放锁。

import java.util.concurrent.TimeUnit;/*** 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个线程，先让线程休眠1秒之后，尝试获取锁，看能不能获取到锁//如果可以获取到锁，说明休眠时线程是释放锁的，而如果获取不到锁，说明是不释放锁的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(1);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("尝试获取sleep方法的锁");synchronized (lock2){System.out.println("成功获取sleep的锁");}},"sleep2");t4.start();}
}

为什么wait释放锁而sleep不释放锁？

JVM 强制语法检查，wait 方法默认等待无期限。

--->PS：（常见面试题）wait 和 sleep 的区别（小结）

二者的相同点：

1. 都可以让线程休眠。
2. 都可以响应 interrupt 中断的请求。
3. wait(num) 和 sleep(num)：当num>0时，二者执行效果一样。

二者的不同点：

1. wait 必须在 synchronized 中使用；而 sleep 却不用。
2. wait 是 Object 的方法（属于对象级别）；而sleep 是 Thread 的方法（属于线程级别）。
3. wait 释放锁；而sleep 不释放锁。
4. wait 有可能无限期地等待下去；而sleep 有明确的终止等待时间。 即：wait 可传参，也可不传参；而 sleep必须要传递一个数值类型的参数，否则会报错。
5. wait 和 sleep 产生的线程状态是不同的：无参的 wait 是 WAITING 状态；而sleep 是 TIMED_WAITING 状态。
6. 一般情况下（响应 interrupt 除过），wait 可以接收一个 notify/notifyAll 之后就继续执行；而 sleep 只能等待超过时间之后再恢复执行。
7. wait(0) 表示无期限地等待；而sleep(0)表示重新触发一次 CPU 竞争。