Java中的wait与sleep区别以及生产者与消费者案例

wait主要用于切换线程，sleep主要用来阻塞当前线程

Java多线程一篇不错的文章推荐下Java多线程

(1)、常用的wait方法有wait()和wait(long timeout);

void wait() 在其他线程调用此对象的 notify() 方法或者 notifyAll()方法前，导致当前线程等待。 
void wait(long timeout)在其他线程调用此对象的notify() 方法 或者 notifyAll()方法，或者超过指定的时间量前，导致当前线程等待。 
wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其他synchronized数据可被别的线程使用。

wait()和notify()因为会对对象的“锁标志”进行操作，所以他们必需在Synchronized函数或者 synchronized block 中进行调用。如果在non-synchronized 函数或 non-synchronized block 中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。。

(2)、Thread.sleep(long millis)必须带有一个时间参数

sleep(long)使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；
sleep(long)可使优先级低的线程得到执行的机会，当然也可以让同优先级的线程有执行的机会；
sleep(long)是不会释放锁标志的。

   public class MultiThreadClient {
        private Consumer consumer;
        private Producer producer;
        private List<Object> mProducts = new ArrayList<>();

        public List<Object> getmProducts() {
            return this.mProducts;
        }

        public void stopThread() {
            consumer.setExit(true);
            producer.setExit(true);
        }

        public void startThread() {
            MultiThreadClient client = new MultiThreadClient();
            //启动多个线程
            consumer = new Consumer(client.getmProducts());
            producer = new Producer(client.getmProducts());
            Thread consumerThread = new Thread(consumer);
            Thread producerThread = new Thread(producer);
            consumerThread.start();
            producerThread.start();
        }
    }

    public class Consumer implements Runnable {
        public volatile boolean exit = false;
        private List<Object> mProducts;
        private int mCount = 0;

        public Consumer(List<Object> products) {
            this.mProducts = products;
        }

        public void setExit(boolean exit) {
            this.exit = exit;
        }

        @Override
        public void run() {
            while (!exit) {
                synchronized (mProducts) {
                    while (mProducts.size() == 0) {
                        try {
                            System.out.println("库存清仓，等待生产者生产，消费者进行等待");
                            mProducts.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    mProducts.remove(0);
                    mProducts.notify();
                    System.out.println("我是消费者，已经消费掉了" + (++mCount) + "个产品" + " 库存数量" + mProducts.size());
                }
            }
        }
    }

    public class Producer implements Runnable {
        public volatile boolean exit = false;
        private List<Object> mProducts;
        private int mCount = 0;
        private static final int mMaxCount = 5;

        public Producer(List<Object> products) {
            this.mProducts = products;
        }

        public void setExit(boolean exit) {
            this.exit = exit;
        }

        @Override
        public void run() {
            while (!exit) {
                synchronized (mProducts) {
                    while (mProducts.size() > mMaxCount) {
                        try {
                            System.out.println("库存已满，等待消费者消费，生产者等待");
                            mProducts.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    mProducts.add(new Object());
                    mProducts.notify();
                    System.out.println("我是生产者，我已经生产了" + (++mCount) + "个产品" + " 库存数量" + mProducts.size());
                }
            }
        }

    }

输出结果：

I/System.out: 库存清仓，等待生产者生产，消费者进行等待
I/System.out: 我是生产者，我已经生产了1个产品 库存数量1
I/System.out: 我是生产者，我已经生产了2个产品 库存数量2
I/System.out: 我是生产者，我已经生产了3个产品 库存数量3
I/System.out: 我是生产者，我已经生产了4个产品 库存数量4
I/System.out: 我是生产者，我已经生产了5个产品 库存数量5
I/System.out: 我是生产者，我已经生产了6个产品 库存数量6
I/System.out: 库存已满，等待消费者消费，生产者等待
I/System.out: 我是消费者，已经消费掉了1个产品 库存数量5
I/System.out: 我是消费者，已经消费掉了2个产品 库存数量4
I/System.out: 我是消费者，已经消费掉了3个产品 库存数量3
I/System.out: 我是消费者，已经消费掉了4个产品 库存数量2
I/System.out: 我是消费者，已经消费掉了5个产品 库存数量1
I/System.out: 我是消费者，已经消费掉了6个产品 库存数量0
I/System.out: 库存清仓，等待生产者生产，消费者进行等待
I/System.out: 我是生产者，我已经生产了7个产品 库存数量1
I/System.out: 我是生产者，我已经生产了8个产品 库存数量2
I/System.out: 我是生产者，我已经生产了9个产品 库存数量3
I/System.out: 我是生产者，我已经生产了10个产品 库存数量4
I/System.out: 我是生产者，我已经生产了11个产品 库存数量5
I/System.out: 我是消费者，已经消费掉了7个产品 库存数量4