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

等待/通知机制的实现

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){

               
d758
        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了，重新进入等待，而不会去执行删除，就避免了这种错误。