10.生产者消费者模型

import java.util.ArrayList;
import java.util.concurrent.Semaphore;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

class Container{
	private ArrayList<Integer> list;
	//其他同步方式
	//private ReentrantLock lock;
	//private Condition condition;
	//private Semaphore sem;
	//private SynchronousQueue<Integer> queue;(专门产生的生产者消费者队列)
	public Container(ArrayList<Integer> list){
		this.list = list;
	}
	
	public synchronized void put(int value){
		while (list.size() > 0){
			try {
				//while循环防止虚假唤醒
				wait(); //进入this对象监视器锁的等待集合
				//唤醒以后,还要继续等待能够持有该监视器锁(从wait状态=>block阻塞状态)
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		list.add(value);
		System.out.println("product:" + value);
		notify();
		
//notify()  唤醒this对象监视器锁等待集合中的某一个线程 => 使该线程进入block状态,其他线程还在等待状态
//notifyAll()  唤醒this对象监视器锁等待集合中的所有线程  => 使所有线程进入block状态
	}
	
	public synchronized int get(){
		while (list.size() <= 0){
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		int value = list.get(list.size()-1);
		list.remove(list.size()-1);
		System.out.println("consume:" + value);
		notify();
		return value;
	}
}

class Producer extends Thread{
	private Container container;
	
	public Producer(Container container){
		this.container = container;
	}
	
	public void run(){
		for (int i = 0; i < 10; ++i){
			container.put(i+1);
		}
	}
}

class Consumer extends Thread{
	private Container container;
	
	public Consumer(Container container){
		this.container = container;
	}
	
	public void run(){
		for (int i = 0; i < 10; ++i){
			container.get();
		}
	}
}

public class TestDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Container container = new Container(new ArrayList<Integer>());
		Consumer c = new Consumer(container);	
		Producer p = new Producer(container);
		p.start();
		c.start();
	}

}

利用SynchronousQueue简单模拟生产者消费者模型

import java.util.concurrent.SynchronousQueue;

class Rongqi{
	private SynchronousQueue<Integer> queue;
	
	public Rongqi(){
		this.queue = new SynchronousQueue<Integer>();
	}
	
	public void put(int value){
		try {
			queue.put(value);
			System.out.println("product:" + value);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public int get(){
		int value = 0;
		try {
			value = queue.take();
			System.out.println("consume:" + value);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return value;
	}
}

class Shengchan extends Thread{
	Rongqi container;
	public Shengchan(Rongqi container){
		this.container = container;
	}
	public void run(){
		for (int i = 0; i < 10; ++i){
			container.put(i+1);
		}
	}
}

class Xiaofei extends Thread{
	Rongqi container;
	public Xiaofei(Rongqi container){
		this.container = container;
	}
	public void run(){
		for (int i = 0; i < 10; ++i){
			container.get();
		}
	}
}

public class SynchronousQueueTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Rongqi container = new Rongqi();
		Shengchan p = new Shengchan(container);
		Xiaofei c = new Xiaofei(container);
		p.start();
		c.start();
	}

}