JavaWeb~线程之间的通信 对象的等待集wait set -- wait() 、notify()

认识对象的等待集

• wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，使当前线程被唤醒(进入“就绪状态”)

• notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程, 然后这些线程再去竞争那同一把锁。(不建议使用notifyAll )

• wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。

• 总结 wait() 的工作过程就是:

1. 释放对象锁(所以必须有一个锁才能正常执行)
2. 等待通知(时间可能会长, 因为不参与后序锁的竞争直到有其他线程调用该对象的notify()去唤醒该线程)
3. 收到通知后 尝试重新获取对象锁 继续往下执行

• ==特别注意: ==

4. wait() 和 notify() 操作必须放在 synchronized 的代码块之内使用 否则会报异常
5. 调用wait() 和 notify() 的对象必须是同一个对象 才能起到等待和唤醒操作 更准确的说 因为wait 和 notify要在 synchronized的代码块内 所以上锁饿对象也应该和wait() 和 notify() 的对象必须是同一个对象 这样就是4个对象得保持一致

wait()方法

• 其实wait()方法就是使线程停止运行。

1. 方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法是用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。
2. wait()方法只能在同步方法中或同步块中调用。如果调用wait()时，没有持有适当的锁，会抛出异常。
3. wait()方法执行后，当前线程释放锁，并一直处于等待通知状态, 直到其他线程唤醒该线程后与其它线程竞争重新获取锁。

public class ThreadTest2 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t = new Thread() {
            @Override
            public void run() {
                synchronized (locker) {
                    System.out.println("t 开始运行");
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(" t 运行结束");
                }
            }
        };
        t.start();
    }
}

notify()方法

• 一个线程执行到object.wait()之后就一直等待下去，那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了另外一个方法唤醒的方法notify()。
• notify方法就是使停止的线程继续运行。

1. 方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个呈wait状态的线程。
2. 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

public class ThreadTest3 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t = new Thread() {
            @Override
            public void run() {
                synchronized (locker) {
                    System.out.println(" t 开始运行");
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(" t 运行结束");
                }
            }
        };
        t.start();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                synchronized (locker) {
                    System.out.println(" t1 开始运行");
                    locker.notify();
                    System.out.println(" t1 运行结束");
                }
            }
        };
        t1.start();

        Thread t2 = new Thread() {
            @Override
            public void run() {
                synchronized (locker) {
                    System.out.println(" t2 开始运行");
                    System.out.println(" t2 运行结束");
                }
            }
        };
        t2.start();
    }
}

• 注意：唤醒线程不能过早，如果在还没有线程在等待中时，过早的唤醒线程，这个时候就会出现先唤醒，在等待的效果了。这样 就没有必要在去运行wait方法了。还会导致竞态条件问题

public class ThreadTest3 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t = new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker) {
                    System.out.println(" t 开始运行");
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(" t 运行结束");
                }
            }
        };
        t.start();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                synchronized (locker) {
                    System.out.println(" t1 开始运行");
                    locker.notify();
                    System.out.println(" t1 运行结束");
                }
            }
        };
        t1.start();

        Thread t2 = new Thread() {
            @Override
            public void run() {
                synchronized (locker) {
                    System.out.println(" t2 开始运行");
                    System.out.println(" t2 运行结束");
                }
            }
        };
        t2.start();
    }
}

竞态条件问题

• 竞态条件问题当一个 t 线程执行了wait()方法释放了对象锁之后 另外一个 t1 线程获取了锁然后立即执行了notify()方法区通知 t 线程 但是 t 线程还没有执行到等待通知的那段代码 所以这个通知就错过了 这样线程 t 就会一直等待下去 这就是一个竞态条件问题
• 为了解决和避免这个问题 事实上当我们在执行wait() 操作的时候 释放锁和等待接收通知是处于一个原子性质上执行的 最后才执行尝试重新获取锁

wait与sleep的对比

1. wait用于线程之间的通信 sleep用于让线程阻塞一段时间
2. wait之前必须要有锁 wait之后会释放锁 等被唤醒之后再重尝试请求锁
3. sleep是无视锁的存在的 即不会要求有锁 也不会去释放锁
4. wait是object的方法
5. sleep是thread的静态方法
6. 唯一相同点就是都可以让线程放弃执行一段时间