Java线程wait与notify，sleep

        在Java中，wait() 和 notify() 方法是用于线程间通信的机制，常常与 synchronized 关键字一起使用，以实现线程的协调和同步。这种机制允许线程之间通过共享对象上的监视器锁来进行通信，并允许线程在等待某些条件满足时挂起自己，直到其他线程通知它们条件已经满足。

1.wait() 方法：

• wait() 方法是 Object 类中的一个实例方法，用于使当前线程进入等待状态，并释放对象的锁。
• 在调用 wait() 方法之前，线程必须获得对象的监视器锁。也就是说synchronized 同步代码块中，必须在锁如果线程尝试在没有获得监视器锁的情况下调用 wait() 方法，会抛出 IllegalMonitorStateException 异常。
• 调用 wait() 方法后，当前线程会释放对象的锁，并进入等待状态，直到其他线程调用相同对象上的 notify() 或 notifyAll() 方法，或者等待一定时间后自动唤醒。

2.notify() 和 notifyAll() 方法：

• notify() 和 notifyAll() 方法也是 Object 类中的实例方法，用于唤醒在此对象上等待的线程。
• 调用 notify() 方法会唤醒在此对象上等待的单个线程，而调用 notifyAll() 方法会唤醒所有等待的线程。
• 调用 notify() 或 notifyAll() 方法并不会立即释放锁，而是等到当前线程执行完同步代码块后才释放。

​​​​​​​下面是一个简单的示例，演示了如何使用 wait() 和 notify() 方法来实现线程间的通信：

3.sleep与wait的对比

共性：

1.由于两者都有一个带有超时时间的版本，且都能让线程进入阻塞状态，并且在这个过程中，时间一到，就解除阻塞，继续执行了

2.两者都可以被提起唤醒，wait被notify唤醒，sleep被interrupt唤醒，详见Java中线程的使用-CSDN博客

区别：

1.wait要在锁中使用，要搭配synchronized，sleep不需要

2.wait的主要目的是不知道要等多少时间的前提下使用的，所谓超时时间是用来兜底的，而sleep主要使用场景是一定要知道等多少时间的前提下使用，虽然能提前唤醒，但是这不是作为“正常的业务流程”

4.使用wait与notifyall来实现线程按一定顺序执行

要求：有三个线程，线程名称分别为：a，b，c。每个线程打印自己的名称。要求顺序为c,b,a.

public static int count= 0;
    public static void main(String[] args) {
        Object locker = new Object();
        Thread thread3 = new Thread(() -> {
            synchronized (locker) {
                while (count!=0) {
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                System.out.println(Thread.currentThread().getName());
                count++;
                locker.notifyAll();
            }
        }, "c");

        Thread thread2 = new Thread(() -> {
            synchronized (locker) {
                while (count!=1) {
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                System.out.println(Thread.currentThread().getName());
                count++;
                locker.notifyAll();
            }
        }, "b");
        Thread thread1 = new Thread(() -> {
            synchronized (locker) {
                while (count!=2) {
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                System.out.println(Thread.currentThread().getName());
                count++;
                locker.notifyAll();
            }
        }, "a");
        thread1.start();
        thread2.start();
        thread3.start();
    }

这段代码创建了三个线程 thread1、thread2 和 thread3，它们分别打印 "a"、"b" 和 "c"，并且打印的顺序是按照 "c，b，a" 的顺序执行。

这是因为在每个线程的执行体内，都使用了一个共享对象 locker 进行同步，并在同步块内部使用了 wait() 和 notifyAll() 方法来实现线程间的协作。具体来说：

• 每个线程在进入同步块后，都会通过 while 循环检查 count 的值是否满足当前线程的打印条件。
• 如果 count 的值不满足条件，线程就会调用 locker.wait() 方法进入等待状态，直到其他线程调用 locker.notifyAll() 方法来唤醒它。
• 当某个线程满足打印条件时，它会打印自己的名字，并将 count 的值加一，然后通过 locker.notifyAll() 方法唤醒其他线程。