线程同步——生产者消费者

了解完线程交互和线程同步后，写下来看一个综合的例子——生产者消费者

／／生产者
public class Producer extends Thread {
    private int neednum;
    private Godown godown;

    Producer(int neednum, Godown godown){
        this.neednum = neednum;
        this.godown = godown;
    }

    @Override
    public void run() {
        godown.produce(neednum);
    }
}

／／消费者
public class Consumer extends Thread {
    private int neednum;
    private Godown godown;

    Consumer(int neednum, Godown godown){
        this.neednum = neednum;
        this.godown = godown;
    }

    @Override
    public void run() {
        godown.consume(neednum);
    }
}

／／仓库
public class Godown {
    public static final int max_size = 100;
    public int curnum;

    public static void main(String[] args) {
        Godown godown = new Godown(30);
        Consumer c1 = new Consumer(50, godown);
        Consumer c2 = new Consumer(20, godown);
        Consumer c3 = new Consumer(30, godown);
        Producer p1 = new Producer(10, godown);
        Producer p2 = new Producer(10, godown);
        Producer p3 = new Producer(10, godown);
        Producer p4 = new Producer(10, godown);
        Producer p5 = new Producer(10, godown);
        Producer p6 = new Producer(10, godown);
        Producer p7 = new Producer(80, godown);
        c1.start();
        c2.start();
        c3.start();
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
        p6.start();
        p7.start();
    }

    Godown() {
    }

    Godown(int curnum) {
        this.curnum = curnum;
    }

    /**
     * 生产指定数量的产品
     */
    public synchronized void produce(int neednum) {
        while (neednum + curnum >= max_size) {
            System.out.println("要生产的产品数量" + neednum + "超过剩余库存量" + (max_size - curnum) + " 暂时不能执行生产任务 !");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //知足生产条件,则进行生产
        curnum += neednum;
        System.out.println("已经生产了" + neednum + "个产品,现仓储量为" + curnum);
        notifyAll();
    }

    /**
     * 消费指定数量的产品
     */
    public synchronized void consume(int neednum) {
        while (curnum < neednum) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        curnum -= neednum;
        System.out.println("已经消费了" + neednum + "个产品,现仓储量为" + curnum);
        notifyAll();

    }
}
／／结果
已经消费了20个产品,现仓储量为10
已经生产了10个产品,现仓储量为20
已经生产了10个产品,现仓储量为30
已经消费了30个产品,现仓储量为0
已经生产了10个产品,现仓储量为10
已经生产了10个产品,现仓储量为20
已经生产了10个产品,现仓储量为30
已经生产了10个产品,现仓储量为40
要生产的产品数量80超过剩余库存量60 暂时不能执行生产任务 !

例子参考：http://lavasoft.blog.51cto.com/62575/221932

上面的例子使用同步方法实现的，下面咱们使用同步代码块实现。

public class Producer extends Thread {
    private int neednum;
    private Godown godown;

    Producer(int neednum, Godown godown) {
        this.neednum = neednum;
        this.godown = godown;
    }

    @Override
    public void run() {
        synchronized (this) {
            while (neednum + godown.getCurnum() >= Godown.max_size) {
                System.out.println("要生产的产品数量" + neednum + "超过剩余库存量" + (Godown.max_size - godown.getCurnum()) + " 暂时不能执行生产任务 !");
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //知足生产条件,则进行生产
            godown.setCurnum(godown.getCurnum() + neednum);
            System.out.println("已经生产了" + neednum + "个产品,现仓储量为" + godown.getCurnum());
            notifyAll();
        }

    }
}

public class Consumer extends Thread {
    private int neednum;
    private Godown godown;

    Consumer(int neednum, Godown godown){
        this.neednum = neednum;
        this.godown = godown;
    }

    @Override
    public void run() {
        synchronized (this){
            while (godown.getCurnum() < neednum) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            godown.setCurnum(godown.getCurnum() - neednum);
            System.out.println("已经消费了" + neednum + "个产品,现仓储量为" + godown.getCurnum());
            notifyAll();
        }
    }
}

public class Godown {
    public static final int max_size = 100;
    public int curnum;

    public int getCurnum() {
        return curnum;
    }

    public void setCurnum(int curnum) {
        this.curnum = curnum;
    }

    public static void main(String[] args) {
        Godown godown = new Godown(30);
        Consumer c1 = new Consumer(50, godown);
        Consumer c2 = new Consumer(20, godown);
        Consumer c3 = new Consumer(30, godown);
        Producer p1 = new Producer(10, godown);
        Producer p2 = new Producer(10, godown);
        Producer p3 = new Producer(10, godown);
        Producer p4 = new Producer(10, godown);
        Producer p5 = new Producer(10, godown);
        Producer p6 = new Producer(10, godown);
        Producer p7 = new Producer(80, godown);
        c1.start();
        c2.start();
        c3.start();
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
        p6.start();
        p7.start();
    }

    Godown(int curnum) {
        this.curnum = curnum;
    }
}