马士兵java并发编程的代码，照抄过来，做个记录。

 

一、分析下面面试题

/** * 曾经的面试题：（淘宝？） * 实现一个容器，提供两个方法，add，size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束 *  * 分析下面这个程序，能完成这个功能吗？ * @author mashibing */package yxxy.c_019;import java.util.ArrayList;import java.util.List;import java.util.concurrent.TimeUnit;public class MyContainer1 {    List lists = new ArrayList();    public void add(Object o) {        lists.add(o);    }    public int size() {        return lists.size();    }        public static void main(String[] args) {        MyContainer1 c = new MyContainer1();        new Thread(() -> {            for(int i=0; i<10; i++) {                c.add(new Object());                System.out.println("add " + i);                                try {                    TimeUnit.SECONDS.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }, "t1").start();                new Thread(() -> {            while(true) {                if(c.size() == 5) {                    break;                }            }            System.out.println("t2 结束");        }, "t2").start();    }}

分析:

不能完成这个功能；

添加volatile关键字，修改为如下：

 

二、添加volatile：

/** * 曾经的面试题：（淘宝？） * 实现一个容器，提供两个方法，add，size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束 *  * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？ * @author mashibing */package yxxy.c_019;import java.util.ArrayList;import java.util.List;import java.util.concurrent.TimeUnit;public class MyContainer2 {    //添加volatile，使t2能够得到通知    volatile List lists = new ArrayList();    public void add(Object o) {        lists.add(o);    }    public int size() {        return lists.size();    }        public static void main(String[] args) {        MyContainer2 c = new MyContainer2();        new Thread(() -> {            for(int i=0; i<10; i++) {                c.add(new Object());                System.out.println("add " + i);                                try {                    TimeUnit.SECONDS.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }, "t1").start();                new Thread(() -> {            while(true) {                if(c.size() == 5) {                    break;                }            }            System.out.println("t2 结束");        }, "t2").start();    }}

但是上面代码还存在两个问题：

1）由于没加同步,c.size()等于5的时候，假如另外一个线程又往上增加了1个，实际上这时候已经等于6了才break，所以不是很精确；

2）浪费CPU，t2线程的死循环很浪费cpu

 

三、使用wait和notify

/** * 曾经的面试题：（淘宝？） * 实现一个容器，提供两个方法，add，size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束 *  * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？ *  * 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁 * 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以 *  * 阅读下面的程序，并分析输出结果 * 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出 * 想想这是为什么？ * @author mashibing */package yxxy.c_019;import java.util.ArrayList;import java.util.List;import java.util.concurrent.TimeUnit;public class MyContainer3 {    //添加volatile，使t2能够得到通知    volatile List lists = new ArrayList();    public void add(Object o) {        lists.add(o);    }    public int size() {        return lists.size();    }        public static void main(String[] args) {        MyContainer3 c = new MyContainer3();                final Object lock = new Object();                new Thread(() -> {            synchronized(lock) {                System.out.println("t2启动");                if(c.size() != 5) {                    try {                        lock.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }                System.out.println("t2 结束");            }                    }, "t2").start();                try {            TimeUnit.SECONDS.sleep(1);        } catch (InterruptedException e1) {            e1.printStackTrace();        }        new Thread(() -> {            System.out.println("t1启动");            synchronized(lock) {                for(int i=0; i<10; i++) {                    c.add(new Object());                    System.out.println("add " + i);                                        if(c.size() == 5) {                        lock.notify();                    }                                        try {                        TimeUnit.SECONDS.sleep(1);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }        }, "t1").start();                    }}

分析：

1）解释wait和notify方法：

使用wait和notify必须进行锁定，如果没有锁定这个对象，你就不能调这个对象的wait和notify方法；

wait和notify是调用被锁定对象的wait和notify方法。

比如有一个对象A，两个线程1,2来访问这个对象A，第一个线程1的访问过程中假如条件没有满足，想让这个线程1暂停，等着；这时候怎么办的呢？

首先线程1要锁定对象A，然后调用这个对象A的wait方法，线程1就进入等待状态，同时释放锁，别的线程可以进来；

 

什么时候线程1会再次启动呢？只有再调用这个对象A的notify方法。notify方法会启动一个正在这个对象A上等待的某一个线程，或者是调用notifyAll(),

notifyAll方法是叫醒在这个对象上正在等待的所有线程。

 

notify无法指定的通知启动哪一个具体的线程，没法指定，由cpu线程调度器自己帮你找一个线程运行。

 

 

 

2）为什么size=5了，t2线程没有结束？

由于notify不会释放锁，即便你通知了t2,让它起来了，它起来之后想往下运行，wait了之后想重新继续往下运行是需要重新得到lock这把锁的，可是很不幸的是t1已经把这个锁锁定了，所以只有等t1执行完了，t2才会继续执行。

 

 

 

四、

/** * 曾经的面试题：（淘宝？） * 实现一个容器，提供两个方法，add，size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束 *  * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？ *  * 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁 * 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以 *  * 阅读下面的程序，并分析输出结果 * 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出 * 想想这是为什么？ *  * notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行 * 整个通信过程比较繁琐 * @author mashibing */package yxxy.c_019;import java.util.ArrayList;import java.util.List;import java.util.concurrent.TimeUnit;public class MyContainer4 {    //添加volatile，使t2能够得到通知    volatile List lists = new ArrayList();    public void add(Object o) {        lists.add(o);    }    public int size() {        return lists.size();    }        public static void main(String[] args) {        MyContainer4 c = new MyContainer4();                final Object lock = new Object();                new Thread(() -> {            synchronized(lock) {                System.out.println("t2启动");                if(c.size() != 5) {                    try {                        lock.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }                System.out.println("t2 结束");                //通知t1继续执行                lock.notify();            }                    }, "t2").start();                try {            TimeUnit.SECONDS.sleep(1);        } catch (InterruptedException e1) {            e1.printStackTrace();        }        new Thread(() -> {            System.out.println("t1启动");            synchronized(lock) {                for(int i=0; i<10; i++) {                    c.add(new Object());                    System.out.println("add " + i);                                        if(c.size() == 5) {                        lock.notify();                        //释放锁，让t2得以执行                        try {                            lock.wait();                        } catch (InterruptedException e) {                            e.printStackTrace();                        }                    }                                        try {                        TimeUnit.SECONDS.sleep(1);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }        }, "t1").start();                    }}

流程图：

 

上面的通信过程太繁琐了，有没有简单点的办法？

 

 

 

五、

/** * 曾经的面试题：（淘宝？） * 实现一个容器，提供两个方法，add，size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束 *  * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？ *  * 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁 * 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以 *  * 阅读下面的程序，并分析输出结果 * 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出 * 想想这是为什么？ *  * notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行 * 整个通信过程比较繁琐 *  * 使用Latch（门闩）替代wait notify来进行通知 * 好处是通信方式简单，同时也可以指定等待时间 * 使用await和countdown方法替代wait和notify * CountDownLatch不涉及锁定，当count的值为零时当前线程继续运行 * 当不涉及同步，只是涉及线程通信的时候，用synchronized + wait/notify就显得太重了 * 这时应该考虑countdownlatch/cyclicbarrier/semaphore * @author mashibing */package yxxy.c_019;import java.util.ArrayList;import java.util.List;import java.util.concurrent.CountDownLatch;import java.util.concurrent.TimeUnit;public class MyContainer5 {    // 添加volatile，使t2能够得到通知    volatile List lists = new ArrayList();    public void add(Object o) {        lists.add(o);    }    public int size() {        return lists.size();    }    public static void main(String[] args) {        MyContainer5 c = new MyContainer5();        CountDownLatch latch = new CountDownLatch(1);        new Thread(() -> {            System.out.println("t2启动");            if (c.size() != 5) {                try {                    latch.await();                                        //也可以指定等待时间                    //latch.await(5000, TimeUnit.MILLISECONDS);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }            System.out.println("t2 结束");        }, "t2").start();        try {            TimeUnit.SECONDS.sleep(1);        } catch (InterruptedException e1) {            e1.printStackTrace();        }        new Thread(() -> {            System.out.println("t1启动");            for (int i = 0; i < 10; i++) {                c.add(new Object());                System.out.println("add " + i);                if (c.size() == 5) {                    // 打开门闩，让t2得以执行                    latch.countDown();                }                try {                    TimeUnit.SECONDS.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }, "t1").start();    }}

 

CountDownLatch(1)，CountDown往下数，当1变为0的时候门闩就开了，latch.countDown()调用一次数就往下-1；

latch.await()，门闩的等待是不需要锁定任何对象的；