线程通信之wait() 和notify() 方法

线程通信之wait() 和notify() 方法

通信方法

wait():调用wait方法的线程，当前持有锁的该线程等待，直至该对象的另一个持锁线程调用notify/notifyAll操作。
wait(long timeOut)、wait(long timeOut,int nanos)

notify():通知持有该对象锁的所有线程中的的随意一个线程被唤醒

notifyAll():通知持有该对象锁的所有线程被同时唤醒

线程通信的方法：wait\notify\notifyAll操作都是属于Object类提供的方法，即所有的对象都具有该方法

使用示例

Wait使用Demo：

public class WaitDemo  extends Thread {
    private Object object;
    public WaitDemo(Object obj) {
        this.object = obj;
    }

    @Override
    public void run() {
        synchronized (object) {
            System.out.println(Thread.currentThread().getName()+ "WaitDemo 执行开始"+ System.currentTimeMillis());
            try {
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ "WaitDemo 执行结束"+ System.currentTimeMillis());
        }
    }
}

Notify使用Demo：

public class NotifyDemo extends Thread {
    private Object object;
    public NotifyDemo (Object o) {
        this.object  = o;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" NotifyDemo 开始执行");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (object) {
            object.notify();
        }
        System.out.println(Thread.currentThread().getName()+" NotifyDemo 执行结束");

    }
}

调用示例：

Object o = new Object();
        new WaitDemo(o).start();
        new NotifyDemo(o).start();

注意：

• 调用notify和wait的必须是作用同一个对象
• 对于wait、notify、notifyAll的调用，必须在该对象的同步方法或者同步代码块中，锁作用的对象和wait等方法必须作用于同一个对象
• wait方法在调用进入阻塞之前会释放锁，而sleep或join是不会释放锁的
• 线程状态转换是，当wait被唤醒或超时，并不是直接进入到运行或者就绪状态，而是先进入到Block状态，抢锁成功后，才能进入到可运行状态

当锁的对象和调用wait/notify的对象不是同一个对象时，会抛出IllegalMonitorStateException
抛出异常：

再看一个问题：

基于以上分析，一旦wait先调用则线程因为锁无法继续执行而阻塞下来，事实是这样嘛？

通过运行测试，程序是可以执行的，为什么？

因为wait方法在调用进入阻塞之前会释放锁，则调用notify操作的线程就可以抢到Object对象的锁，进而调用notify方法

锁池和等待池

锁池：获取同一把锁的线程，在为抢夺锁时会进入到锁池

等待池：调用wait操作的线程，会释放掉锁，进入到该对象的等待池中

notify和nitifyAll的区别：

notify唤醒的是对象等待池中的一个线程，这个线程会进入到blocked状态，也叫做进入锁池中，等待获取锁之后才能继续执行
notifyAll调用会唤醒对象等待池中的所有线程，所有线程进入bloked的状态，即锁池，所有线程来竞争获取锁，竞争到锁的线程才有资格执行

实际案例使用：

有三个线程，分别为A、B、C线程，需要线程交替打印：ABCABCABC…打印10次有三个线程，分别为A、B、C线程，需要线程交替打印：ABCABCABC…打印10次

自定义线程间通信的类：

public class Opt {
    //下一个执行的线程编号
    private Integer nextIndex;

    public Integer getNextIndex() {
        return nextIndex;
    }

    public void setNextIndex(Integer nextIndex) {
        this.nextIndex = nextIndex;
    }
}

子线程的实现：

public class ABCThread extends Thread {
    String [] ABC = new String[]{"A","B","C"};
    //当前线程编号
    private Integer index;
    //线程间通信的对象
    private Opt opt;

    //统计当前线程打印次数
    int num = 0;

    public ABCThread(Integer index,Opt opt) {
        this.index = index;
        this.opt = opt;
    }

    @Override
    public void run() {
        while (true) {
            //锁通信的对象
            synchronized (opt) {
                //循环执行 判断是否是当前线程执行 （当先线程编号和opt记录的线程编号一致则是要执行的线程）
                //需要循环操作 A ->B和C
                while (opt.getNextIndex() != index) {
                    try {
                        //不是当前线程执行，继续等待
                        opt.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                System.out.print(ABC[index] +" ");
                //统计次数+1
                num++;

                //设置下一个执行的线程编号 A：（0 -1） ->B(1 ->2) ->C(2-0)
                opt.setNextIndex((index+1)%3);

                //通知其他的两个线程
                opt.notifyAll();

                //当前执行到达10次，执行结束
                if (num > 9) break;
            }
        }
    }
}

调用：

 public static void main(String[] args) {
        Opt opt = new Opt();
        //设置第一个执行的线程编号
        opt.setNextIndex(0);
        new ABCThread(0,opt).start();//A线程
        new ABCThread(1,opt).start();//B线程
        new ABCThread(2,opt).start();//C线程
    }