java多线程并发之线程间的通信

1.什么叫做等待通知？
就好比如：服务员等待厨师拿菜的过程叫做等待；厨师做好了菜按铃通知服务员叫做通知。
而在单线程编程中,要执行的操作需要满足一定的条件才能执行,可以把这个操作放在 if 语句中；在多线程编程中,可能 A 线程的条件没有满足只是暂时的, 稍后其他的线程 B 可能会更新条件使得 A 线程的条件得到满足. 可以将 A 线程暂停,直到它的条件得到满足后再将 A 线程唤醒.它的伪代码:

atomics{ //原子操作
while( 条件不成立 ){
   等待
  }
     当前线程被唤醒条件满足后,继续执行下面的操作
}

2.等待通知机制的实现

2.1wait()

Object 类中的 wait()方法可以使执行当前代码的线程等待,暂停执行,直到接到通知或被中断为止.。注意:

1. wait()方法只能 在同步代码块中由锁对象调用
2. 调用 wait()方法,当前线程会释放锁

其构造方法如下：

具体可见Object类

其伪代码如下:

//在调用 wait()方法前获得对象的内部锁
synchronized( 锁对象 ){
while( 条件不成立 ){
//通过锁对象调用 wait()方法暂停线程,会释放锁对
锁对象.wait();
  }
//线程的条件满足了继续向下执行
}

代码示例如下：

package com.company.wait;

/***
 * 演示wait()会使线程等待，必须要放在同步代码块中，通过锁对象调用
 */
public class WaitTest {
    public static void main(String[] args) {
        String text="wesf";
        String other="jisf";

       // wait()继承Object类任何对象都可以调用
        //但此种写法报java.lang.IllegalMonitorStateException异常，因为wait()必须要放在同步代码块中
//        try {
//            text.wait();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        try {
            System.out.println("同步代码块之前");
            synchronized (text){
                System.out.println("同步代码块开始");
                text.wait();//调用wait()方法后，当前的线程就会等待，释放锁对象，当前线程需要被唤醒，如果没有被唤醒就会一直处于等待状态
                //other.wait();//不是锁对象调用会产生java.lang.IllegalMonitorStateException异常
                System.out.println("wait之后");
            }
            System.out.println("同步代码块后面的代码");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main后面的其他代码");

    }
}

结果输出如下图：
2.2Interrupt()
当线程处于 wait()等待状态时, 调用线程对象的 interrupt()方法会
中断线程的等待状态, 会产生 InterruptedException 异常

代码例示如下：

package com.company.wait;

public class InterruptAndWait {
    public static void main(String[] args) {
        SubThread t=new SubThread();
        t.start();
        try {
            Thread.sleep(2000);//主线程睡眠两秒，确保子线程处于wait等待状态
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
    }

    private static final Object LOCK=new Object();//定义一个常量作为锁对象
    static class SubThread extends Thread{
        @Override
        public void run() {
            synchronized (LOCK){
                try {
                    System.out.println("begin wait......");
                    LOCK.wait();
                    System.out.println("end wait");
                } catch (InterruptedException e) {
                    System.out.println("wait等待被中断了");
                    e.printStackTrace();
                }
            }
        }
    }
}

结果输出如下：

2.3 notify()
Object 类的 notify()可以唤醒线程,该方法也必须在同步代码块中
由 锁 对 象 调 用 . 没 有 使 用 锁 对 象 调 用 wait()/notify() 会 抛 出IlegalMonitorStateExeption 异常. 如果有多个等待的线程,notify()方法只能唤醒其中的一个. 在同步代码块中调用 notify()方法后,并不会立即释放锁对象,需要等当前同步代码块执行完后才会释放锁对象,一般将 notify()方法放在同步代码块的最后. 它的伪代码如下:

synchronized( 锁对象 ){
//执行修改保护条件 的代码
//唤醒其他线程
锁对象.notify();
}

代码示例如下：

package com.company.notify;

/***
 * notify()，可以唤醒线程，也需要在同步代码块中由锁对象调用
 */
public class NotifyTest {
    public static void main(String[] args) {
        String lock="efef";//定义一个字符串作为锁对象
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock){
                    System.out.println("线程i开始等待："+System.currentTimeMillis());
                    try {
                        lock.wait();//线程等待，会释放锁对象，当前线程转入blocked状态
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程i结束等待："+System.currentTimeMillis());
                }
            }
        });

        //定义第二个线程，在第二个线程中唤醒第一个线程
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock){
                    System.out.println("线程2开始唤醒："+System.currentTimeMillis());
                    lock.notify();//幻想在lock锁对象上的某一个线程，不会立即释放锁对象，而是等待第二个线程结束后才释放锁对象，然后正在等待的线程才会获得锁对象
                    System.out.println("线程2结束唤醒："+System.currentTimeMillis());
                }
            }
        });
        t1.start();//开启t1线程，t1线程等待
        try {
            Thread.sleep(3000);//main线程睡眠3秒，确保t1入睡
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();//t1线程开启3秒后，再开启t2线程
    }
}

备注：notify不会立即释放锁对象，而是等到当前同步代码块执行完毕后才会释放。具体可以看如上代码所示。

结果输出如下图所示：
备注：notify()可以唤醒一个线程，notifyAll()可以唤醒所有的线程。