多线程之初理解

生产者和消费者模式

生产者生产20个模具后，消费者开始消费，消费完之后，生产者又开始生产，周而复始......

工厂：

package com.xiaohao.output;

import java.util.ArrayList;
import java.util.List;

/**
 * 注意几点：
 * 1.0 wait(),notifyAll()必须和同步锁一起使用
 * 2.0 一个线程wait()之后，当再次被notifyAll()之后，是接着执行wait()之后的代码，所以，想要达到生产
 * 无限循环的效果，必须将wait()放在while或for语句之中
 * 3.0 notifyAll()在wait()之前使用，这样会起到交互执行的效果
 * @author Administrator
 *
 */
public class CacheArea {
	private List<Model> models = new ArrayList<Model>();
	private static int maxSize = 20;
	public synchronized void putModel() {
		while(models.size() < maxSize) {
			models.add(new Model());
			System.out.println("放入一个模具，模具总数：  " + models.size());
			if(models.size() == maxSize) {
				System.out.println("箱子已经装满了!");
				notifyAll();
				try {
					wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
	public synchronized void getModel() {
		while(models.size() > 0) {
			models.remove(0);
			System.out.println("消费一个模具，模具总数： " + models.size());
			if(models.size() == 0) {
				System.out.println("箱子没有模具了！");
				notifyAll();
				try {
					wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

生产者：

package com.xiaohao.output;

public class Producer implements Runnable{
	private CacheArea c;
	
	public Producer(CacheArea c) {
		this.c = c;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		c.putModel();
	}

}

消费者：

package com.xiaohao.output;

public class Consumer implements Runnable {
	private CacheArea c;
	public Consumer(CacheArea c) {
		this.c = c;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		c.getModel();
	}

}

测试代码：

package com.xiaohao.test;


import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


import org.junit.Test;


import com.xiaohao.output.CacheArea;
import com.xiaohao.output.Consumer;
import com.xiaohao.output.Producer;


public class TestOutput {
private CountDownLatch latch = new CountDownLatch(100);//用Junit测试多线程

@Test
public void OutPutTest01() {

ExecutorService exe = Executors.newCachedThreadPool();
CacheArea c = new CacheArea();
exe.execute(new Producer(c));
exe.execute(new Consumer(c));
try {

latch.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

输出结果：

放入一个模具，模具总数：  1
放入一个模具，模具总数：  2
放入一个模具，模具总数：  3
放入一个模具，模具总数：  4
放入一个模具，模具总数：  5
放入一个模具，模具总数：  6
放入一个模具，模具总数：  7
放入一个模具，模具总数：  8
放入一个模具，模具总数：  9
放入一个模具，模具总数：  10
放入一个模具，模具总数：  11
放入一个模具，模具总数：  12
放入一个模具，模具总数：  13
放入一个模具，模具总数：  14
放入一个模具，模具总数：  15
放入一个模具，模具总数：  16
放入一个模具，模具总数：  17
放入一个模具，模具总数：  18
放入一个模具，模具总数：  19
放入一个模具，模具总数：  20
箱子已经装满了!
消费一个模具，模具总数： 19
消费一个模具，模具总数： 18
消费一个模具，模具总数： 17
消费一个模具，模具总数： 16
消费一个模具，模具总数： 15
消费一个模具，模具总数： 14
消费一个模具，模具总数： 13
消费一个模具，模具总数： 12
消费一个模具，模具总数： 11
消费一个模具，模具总数： 10
消费一个模具，模具总数： 9
消费一个模具，模具总数： 8
消费一个模具，模具总数： 7
消费一个模具，模具总数： 6
消费一个模具，模具总数： 5
消费一个模具，模具总数： 4
消费一个模具，模具总数： 3
消费一个模具，模具总数： 2
消费一个模具，模具总数： 1
消费一个模具，模具总数： 0
箱子没有模具了！

......