生产者与消费者

package j03.a13Thread;

public class ProductThread {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producter producter = new Producter(clerk);
        Consumer consumer = new Consumer(clerk);
        Thread thread1 = new Thread(producter);
        thread1.setName("生产者");
        Thread thread2 = new Thread(consumer);
        thread2.setName("消费者");
        thread1.start();
        thread2.start();
    }

    public static class Clerk {
        // 产品数量
        int productNums = 0;

        // 增加产品数量,获取到的数量达到20个后，将不会继续增加。就等待消费者来取东西了
        public synchronized void addProduct() {
            if (productNums >= 20) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                productNums = productNums + 1;
                System.out.println(Thread.currentThread().getName() + ":" + "添加了第" + productNums + "个产品");
                notifyAll();// 产品数量没到上限，通知其他线程来进行存或则取
                // notify();
            }
        }

        public synchronized void getProduct() {
            if (productNums <= 0) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                System.out.println(Thread.currentThread().getName() + ":" + "买走了第" + productNums + "个产品");
                productNums = productNums - 1;
                notifyAll();// 产品数量没到下限，通知其他线程来进行存或则取
            }
        }
    }

    // 生产者要执行的线程
    public static class Producter implements Runnable {

        private Clerk clerk;

        public Producter(Clerk clerk) {
            this.clerk = clerk;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    // 不知道什么时候生产者回来添加产品,所以用一个随机时间来让进行线程随眠,来模仿生产者来访的不定时
                    // Thread.sleep((int) (Math.random() * 10) * 100);
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                clerk.addProduct();
            }
        }
    }

    // 消费者需要执行的线程
    public static class Consumer implements Runnable {

        private Clerk clerk;

        public Consumer(Clerk clerk) {
            this.clerk = clerk;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    // 不知道什么时候消费者回来添加产品,所以用一个随机时间来让进行线程随眠,来模仿消费者来访的不定时
                    // Thread.sleep((int) (Math.random() * 10) * 100);
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                clerk.getProduct();
            }
        }
    }
}

1-sleep是线程类（Thread）的方法，
2-调用sleep不会释放对象锁。
3-导致此线程暂停执行指定时间，把执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。

1-wait是Object类的方法，
2-对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，
3-只有针对此对象发出notify方法（或notifyAll）后，本线程才进入对象锁定池准备获得对象锁进入运行状态。