java线程协作，经典生产者/消费者模式(一、synchronized互斥)

java多线程协作，最经典的就是生产者/消费者模式，，比如，一个盘子（缓冲区），假如这个盘子最多只能放一个苹果。现在如果我要从盘里拿出一个苹果，首先要保证盘里有苹果，如果没有，就要等到放入了才能拿；同样，我如果要放一个苹果到盘子里，就要保证盘子里面现在没有苹果，如果有，就要等拿走了又才能放。下面贴上实现放入苹果/拿出苹果这个过程的线程代码：

/**
 * java线程协作，生产者/消费者
 * @author 李小拐
 * 2016年6月20日20:36:56
 */
public class Plate {
	
	private static int plate=0;//声明一个变量,代表盘子，可以放入和拿出
	//放入一个苹果,使用synchronized关键字
	public synchronized void putApple() throws InterruptedException {
		while (plate==1) {
			this.wait();//如果有苹果，不能再放了，就等待
		}
		System.out.println("放入apple");
		plate=1;
		this.notifyAll();//放入后，唤醒等待的线程
	}
	//拿出一个苹果,使用synchronized关键字
	public synchronized void getApple() throws InterruptedException {
		while (plate==0) {
			this.wait();//如果盘子为空，则不能取，等待放入苹果才能取
		}
		System.out.println("拿出苹果");
		plate=0;
		this.notifyAll();//取出后，唤醒等待线程
	}
	
	public static void main(String[] args) {
		Plate plate=new Plate();
		for (int i = 0; i < 200; i++) {//put和get各执行20次
			new getApple(plate).start();
			new putApple(plate).start();
		}
	}
}
//拿出苹果的线程
class getApple extends Thread{
	private Plate plate;
	public getApple(Plate plate) {
		this.plate=plate;
	}
	@Override
	public void run() {
		try {
			plate.getApple();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

//放入苹果的线程
class putApple extends Thread{
	private Plate plate;
	public putApple(Plate plate) {
		this.plate=plate;
	}
	@Override
	public void run() {
		try {
			plate.putApple();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

以上这个列子就是经典的生产者/消费者模式，如果有不正确的地方，请看见的大神指出来，以免误导了后面学习的人。

下面，在贴一段经典面试题的代码：大致需求如下，开启ABC三个线程，A打印A,B打印B,C打印C,ABC三个线程同时启动，顺序输入ABC，如此循环10次。

/**
 * 生产者/消费者 :顺序打印ABCD
 * @author 李小拐
 * 2016年6月20日21:00:36
 */
public class PrintABCD {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//一定是在这里new一个对象，不能再线程里面new,否则多个线程就不是操作的同一个内存对象
		PrintABCD abcd=new PrintABCD();
		
		for (int i = 0; i < 10; i++) {
			(new printA(abcd)).start();
			(new printB(abcd)).start();
			(new printC(abcd)).start();
			(new printD(abcd)).start();
		}
	}

	private static int who=1;//用变量who来控制要打印的值;1,2,3，4分别代表A,B,C,D
	
	public synchronized void printA() throws InterruptedException {
		while (who!=1) {
			this.wait();//不等于1就等待，等于1的时候才执行
		}
		System.out.println("A");
		who=2;//A的下一状态B
		this.notifyAll();
	}
	
	public synchronized void printB() throws InterruptedException {
		while (who!=2) {
			this.wait();
		}
		System.out.println("--B");
		who=3;//B的下一状态C
		this.notifyAll();
	}
	
	public synchronized void printC() throws InterruptedException {
		while (who!=3) {
			this.wait();
		}
		System.out.println("----C");
		who=4;//C的下一状态D
		this.notifyAll();
	}
	
	public synchronized void printD() throws InterruptedException {
		while (who!=4) {
			this.wait();
		}
		System.out.println("------D");
		who=1;//D的下一状态A
		this.notifyAll();
	}
}
//四个线程，分别打印ABCD
class printA extends Thread{
	PrintABCD p;
	printA(PrintABCD p){
		this.p=p;
	}
	@Override
	public void run() {
		try {
			p.printA();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
class printB extends Thread{
	PrintABCD p;
	printB(PrintABCD p){
		this.p=p;
	}
	@Override
	public void run() {
		try {
			p.printB();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
class printC extends Thread{
	PrintABCD p;
	printC(PrintABCD p){
		this.p=p;
	}
	@Override
	public void run() {
		try {
			p.printC();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
class printD extends Thread{
	PrintABCD p;
	printD(PrintABCD p){
		this.p=p;
	}
	@Override
	public void run() {
		try {
			p.printD();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

这里打印了ABCD，其实和ABC是一样的，只是demo里面多写了一个。synchronized关键字保证了线程的互斥。JDK1.5以前基本都使用synchronized关键字进行线程间协作，JDK1.5以后提供了更高级的通信方式，我将在下一篇文章贴出demo代码。

最后一句，学无止境，文章若有不足之处，请大神们及时指正，，纠正了我，也及时避免误导后人