多线程 等待/通知机制的实现

等待/通知机制的实现
1. 概述
    * 方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，
        该方法用来将当前线程置入"预执行队列"中，并且在wait()所在的代码行处停止执行，
        直到接到通知或被中断为止。在调用wait()之前，线程必须获得该对象的对象级别锁，
        即只能在同步方法或同步块中调用wait()方法。在执行wait()方法后，当前对象释放锁。


    * 方法notify()也要在同步方法或者同步块中调用，即在调用前，线程也必须获得该对象的对象
    级别锁。该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由
    线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify,并使它等待获取该对象
    的对象锁。
        注意：在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能
            马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized
            代码块后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。


    * 总结
        wait使线程停止运行，而notify使停止的线程继续运行。
2. notify()方法后当前线程还是会继续执行完：
    eg:
        public class MyList {
        private static List<String> list=new ArrayList<>();
        public static void add(){
            list.add("anyString");
        }
        public static int size(){
            return list.size();
        }
    }


        public class ThreadA extends Thread{
        private Object lock;
        public ThreadA(Object lock){
            super();
            this.lock=lock;
        }
        @Override
        public void run() {
            try{
                synchronized (lock){
                    if(MyList.size()!=5){
                        System.out.println("wait begin "+System.currentTimeMillis());
                        lock.wait();
                        System.out.println("wait end "+System.currentTimeMillis());
                    }
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }


        public class ThreadB extends Thread{
        private Object lock;
        public ThreadB(Object lock){
            super();
            this.lock=lock;
        }
        @Override
        public void run() {
            try{
                synchronized (lock){
                    for(int i=0;i<10;i++){
                        MyList.add();
                        if(MyList.size()==5){
                            lock.notify();
                            System.out.println("已发出通知！");
                        }
                        System.out.println("添加了"+(i+1)+"个元素！");
                        Thread.sleep(1000);
                    }
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }


        public class Run {
        public static void main(String[] args){
            try{
                Object lock=new Object();
                ThreadA a=new ThreadA(lock);
                a.start();
                Thread.sleep(50);
                ThreadB b=new ThreadB(lock);
                b.start();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }


    结果：
        wait begin 1503146432420
        添加了1个元素！
        添加了2个元素！
        添加了3个元素！
        添加了4个元素！
        已发出通知！
        添加了5个元素！
        添加了6个元素！
        添加了7个元素！
        添加了8个元素！
        添加了9个元素！
        添加了10个元素！
        wait end 1503146442540


3. 方法wait()锁释放与notify()锁不释放
    wait()方法执行到时，该线程就会释放锁，notify()方法执行时，线程不会释放锁，并且代码会执行完毕，执行完毕后才释放锁。


4. 当interrupt方法遇到wait方法


    当线程wait()状态时，调用线程对象的interrupt()方法会出现InterruptedException异常。
    eg:
        public class Service {
        public void testMethod(Object lock){
            try{
                synchronized (lock){
                    System.out.println("begin wait()");
                    lock.wait();
                    System.out.println("  end wait()");
                }
            }catch (InterruptedException e){
                e.printStackTrace();
                System.out.println("出现异常了，因为呈wait状态的线程被interrupt了！");
            }
        }
    }


        public class ThreadA extends Thread {
        private Object lock;
        public ThreadA(Object lock){
            super();
            this.lock=lock;
        }
        @Override
        public void run() {
            Service service=new Service();
            service.testMethod(lock);
        }
    }


        public class Test {
        public static void main(String[] args){
            try{
                Object lock=new Object();
                ThreadA a=new ThreadA(lock);
                a.start();
                Thread.sleep(5000);
                a.interrupt();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
        效果：
        begin wait()
        出现异常了，因为呈wait状态的线程被interrupt了！
        java.lang.InterruptedException
            at java.lang.Object.wait(Native Method)
            at java.lang.Object.wait(Object.java:502)
            at org.fkit.six.Service.testMethod(Service.java:11)
            at org.fkit.six.ThreadA.run(ThreadA.java:16)


        * 从上可以看出：
            * 在执行同步代码块的过程中，遇到异常而导致线程终止，锁也会被释放。
            * 在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程
                会释放对象锁，而此线程对象会进入线程等待池中，等待被唤醒。


5. 只通知一个线程
    调用方法notify()一次只随机通知一个线程进行唤醒


6. 唤醒所有线程
    使用notifyAll()方法可以唤醒所有该锁上的线程


7. 方法wait(long)的使用
    带一个参数的wait(long)方法的功能是等待某一时间内是否有线程对锁进行唤醒，
        如果超过这个时间则自动唤醒。


8. 等待wait的条件发生变化(难点哦)
    * 在使用wait/notify模式时，还需要注意另外一种情况，也就是wait等待的条件发生了变化，
        也容易造成程序逻辑的混乱。
        eg:
                public class ValueObject {
                public static List<String> list=new ArrayList<>();
            }
                public class Add {
                private String lock;
                public Add(String lock){
                    super();
                    this.lock=lock;
                }
                public void add(){
                    synchronized (lock){
                        ValueObject.list.add("anyString");
                        lock.notifyAll();
                    }
                }
            }


                public class Subtract {
                    private String lock;
                    public Subtract(String lock){
                        super();
                        this.lock=lock;
                    }
                    public void subtract(){
                        try{
                            synchronized (lock){
                                if(ValueObject.list.size()==0){
                                    System.out.println("wait begin ThreadName="+Thread.currentThread().getName());
                                    lock.wait();
                                    System.out.println("wait  end ThreadName="+Thread.currentThread().getName());
                                }
                                ValueObject.list.remove(0);
                                System.out.println("list size="+ValueObject.list.size());
                            }
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                }


                public class ThreadSubtract extends Thread{
                private Subtract r;
                public ThreadSubtract(Subtract r){
                    super();
                    this.r=r;
                }


                @Override
                public void run() {
                    r.subtract();
                }
            }


                public class ThreadAdd extends Thread {
                private Add p;
                public ThreadAdd(Add p){
                    super();
                    this.p=p;
                }


                @Override
                public void run() {
                    p.add();
                }
            }
                public class Run {
                public static void main(String[] args) throws InterruptedException{
                    String lock=new String("");
                    Add add=new Add(lock);
                    Subtract subtract=new Subtract(lock);
                    ThreadSubtract subtract1Thread=new ThreadSubtract(subtract);
                    subtract1Thread.setName("subtract1Thread");
                    subtract1Thread.start();
                    ThreadSubtract subtract2Thread=new ThreadSubtract(subtract);
                    subtract2Thread.setName("subtract2Thread");
                    subtract2Thread.start();
                    Thread.sleep(1000);
                    ThreadAdd addThread=new ThreadAdd(add);
                    addThread.setName("addThread");
                    addThread.start();
                }
            }
            效果：
            wait begin ThreadName=subtract1Thread
            wait begin ThreadName=subtract2Thread
            wait  end ThreadName=subtract2Thread
            Exception in thread "subtract1Thread" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
            list size=0
                at java.util.ArrayList.rangeCheck(ArrayList.java:653)
            wait  end ThreadName=subtract1Thread
                at java.util.ArrayList.remove(ArrayList.java:492)
                at org.fkit.seven.Subtract.subtract(Subtract.java:20)
                at org.fkit.seven.ThreadSubtract.run(ThreadSubtract.java:15)


            分析：因为我们有两个线程在等待删除，而插入只执行了一次，却唤醒了两个线程，去删除的时候当然会出现错误，
                做如下修改就可以解决问题
                    public class Subtract {
                    private String lock;
                    public Subtract(String lock){
                        super();
                        this.lock=lock;
                    }
                    public void subtract(){
                        try{
                            synchronized (lock){
                                while(ValueObject.list.size()==0){
                                    System.out.println("wait begin ThreadName="+Thread.currentThread().getName());
                                    lock.wait();
                                    System.out.println("wait  end ThreadName="+Thread.currentThread().getName());
                                }
                                ValueObject.list.remove(0);
                                System.out.println("list size="+ValueObject.list.size());
                            }
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                }
                分析：现在来考虑这个问题，当我们线程被唤醒成功的时候，不是立即去执行删除操作，而是回头再去判断一次，因为线程
                    被同步了，顺序执行，当第二个线程执行到的时候就已经为0了，重新进入等待，而不会去执行删除，就避免了这种错误。