Java多线程解决生产者和消费者问题（面向对象）

假设是生产者-->做面包-->>放到面包柜-->>消费者从面包柜买面包

这里我们需要以下几个类

1：首先，是面包类，叫Bread，它有个成员属性叫name，用于区分哪个面包

2：柜，它应该是用来放置面包使用的，叫Container,每个柜应该有自己的容纳空间，定义一个成员属性叫size

3：生产者类，Creator他有个成员方法，实现runnable接口

4：消费者类，Consumer有个成员方法，实现runnable接口

5：主线程类，控制程序运行

废话不多说，上代码：

MainThread.java

import java.util.ArrayList;

public class MainThread {
	
	public static void main(String[] args){
		Container container = new Container();
		container.setIndex(0);
		container.setSize(20);
		container.setBreads(new ArrayList<Bread>());
		Creator creator1 = new Creator();
		Creator creator2 = new Creator();
		Consumer consumer = new Consumer();
		creator1.setContainer(container);
		creator2.setContainer(container);
		consumer.setContainer(container);
		new Thread(creator1).start();
		new Thread(creator2).start();
		new Thread(consumer).start();
	}
}

Bread.java

public class Bread {
	
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

Container.java

import java.util.List;

public class Container {

	private int size;

	private List<Bread> breads;

	private int index;

	public int getSize() {
		return size;
	}

	public void setSize(int size) {
		this.size = size;
	}

	public List<Bread> getBreads() {
		return breads;
	}

	public void setBreads(List<Bread> breads) {
		this.breads = breads;
	}

	public int getIndex() {
		return index;
	}

	public void setIndex(int index) {
		this.index = index;
	}

	// 生产面包
	public synchronized void createBread() {
		while (index == size) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notifyAll();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		Bread bread = new Bread();
		bread.setName("第  " + (index+1) + " 个面包");
		this.getBreads().add(bread);
		System.out.println("生产 "
				+ this.getBreads().get(this.getIndex()).getName());
		index++;
		this.setIndex(index);
	}
	
	//消费面包
	public synchronized void buyBread(){
		while(index == 0){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notifyAll();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("消费  "+this.getBreads().get(this.getIndex()-1).getName());
		this.getBreads().remove(index-1);
		index--;
		this.setIndex(index);
	}

}

Creator.java

package com.wangkunfeng.threads;

public class Creator implements Runnable{

	private Container container;
	
	//得到装面包的容器
	public void setContainer(Container container){
		this.container = container;
	}
	
	@Override
	public void run() {
		for(int i =0 ;i<10;i++){
			this.container.createBread();
		}
	}
}

Consumer.java

package com.wangkunfeng.threads;

public class Consumer implements Runnable {

	private Container container;

	public void setContainer(Container container) {
		this.container = container;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.container.buyBread();
		}
	}

}

待解决问题：其实Container类的createBread和buyBread方法面向对象角度应该放在Creator类和Consumer类里面，但是这样子同步问题不好解决。