java解决生产者与消费者的多线程问题

[baibaishen.csdn]

日常生活版：
有四个工厂分别为A、B、C、D，分别向一个仓库（仓库货容量为11）中放入产品。工厂A只能生产产品1（用数字1表示），工厂B只能生产产品2，工厂C只能生产产品3，工厂D只能生产产品4，四个工厂所生产产品入库的顺序为1,2,3,4,1,2,3,4,1……。同时有一个经销商E从仓库中按入库先后顺序取出产品（每次去一个，以打印对应产品的数字编号的形式表示取出成功）。要求打印数字的顺序为插入顺序（各个工厂生产的产品数均为100），并且完成全部入库出库操作耗时控制在200毫秒以内。

程序员版：
有四个生产者线程A、B、C、D，分别向一个固定大小为11的storage数组(int storage[]=new int[15];)中插入数据。线程A只能插入数字1，线程B只能插入数字2，线程C只能插入数字3，线程D只能插入数字4，插入的数字顺序为1,2,3,4,1,2,3,4,1……。同时有一个消费者线程E从storage数组中取出数字（每次取一个，取出来之后就打印这个数字）。要求打印数字的顺序为插入顺序（每个线程插入100次各自的数字），完成全部入库出库操作耗时控制在200毫秒以内。

[chichenzhe]

生产者 消费者模型 的代码 网上一堆一堆的 随意搜几个来看看就得了... 弄简单点 直接用 阻塞有界队列. 生产者不停往里塞 或者根据逻辑往里塞. 消费者直接 while-true 线程从队列里面get. 如果队列为空消费者线程自动会阻塞(阻塞有界队列的特性), 阻塞后CPU自动释放了. ----- 而且你的思路就不对. 多线程程序 不是为了保证你的执行是有序的, 多线程以及生产者消费者存在的目的就是为了 无序的添加和无序的使用. 以避免你使用 while-true-sleep 这种浪费CPU并且性能不佳的方式... 所以... 你先得搞清楚为什么 while-true-sleep 这种方式性能不佳 之后你才有资格去讨论如何实现以及为什么要实现多线程的生产者和消费者模型.

[zs808]

这个课题的核心在于200ms以内，并且要保证生产者线程生产的数据要严格有序，而且也规定了一些基本的数据结构（比如storge数组存储生产线内容）。 我的思路就是，通过一个state原子量来保证生产者输出的数字顺序，通过两个信号量来确保生产者与消费者同步（因为storge是一个有界的数组）。 下面是我的实现代码，lz可以借鉴下，如果有好的建议，欢迎提出~

package org.imzhs.learn.test;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class App {
	public static AtomicInteger state = new AtomicInteger(0); //用来保证生产顺序的状态量
	public static int[] storage = new int[11];  //生产线
	public static AtomicInteger currentStorageIndex = new AtomicInteger(0); //生产线指针
	public static ReentrantLock syncLock = new ReentrantLock(false); //用来保证消费者消费与生产者生产进行同步的lock
	public static Condition consumeCondition = syncLock.newCondition(); //消费者同步信号量
	public static Condition productCondition = syncLock.newCondition(); //生产者同步信号量
	public static CountDownLatch latch = new CountDownLatch(5);  //用来监视所有生产者线程是否执行完毕的latch

	//消费者
	public static class Consumer implements Runnable {
		public AtomicBoolean isStarted = new AtomicBoolean(false);

		@Override
		public void run() {
			while (latch.getCount() > 0) {
				try {
					isStarted.set(true);
					syncLock.lock();
					//等待生产线变满
					consumeCondition.await();
					for (int i = 0; i < storage.length; i++) {
						if (storage[i] != 0) {
							System.out.print(storage[i]);
							storage[i] = 0;
						}
					}
					//重置生产线指针
					currentStorageIndex.set(0);;
					productCondition.signalAll();
				} catch (InterruptedException e) {
				} finally {
					syncLock.unlock();
				}
			}
		}
	}

	//生产者
	public static class Productor implements Runnable {
		public int expect; //前置量，状态为该值，才会加入生产线
		public int number; //生产量，即加入生产线的量，生产完毕会将状态量设置为该量
		public int repeat; //重试次数

		@Override
		public void run() {
			while (repeat > 0) {
				int currentState = state.get();
				if (expect == currentState) {
					//双重校验
					if (state.get() == currentState) {
						try {
							syncLock.lock();
							//CAS，保证多线程环境下的state并发修改的happends-before（1,2,3,4,0顺序）
							if (state.compareAndSet(expect, number)) {
								int index = currentStorageIndex.incrementAndGet();
								if (index >= storage.length) {
									if(index == storage.length + latch.getCount() - 1){ 
										//此时所有生产者会处于停滞状态，需要启动通知消费者进行消费
										consumeCondition.signalAll();
									}
									//等待消费者消费
									productCondition.await();
								} else {
									repeat--;
									storage[index] = expect;
								}
							}
						} catch (InterruptedException e) {
						} finally {
							syncLock.unlock();
						}
					}
				} else {
					Thread.yield();
				}
			}
			latch.countDown();
		}

		public Productor(int expect, int number, int repeat) {
			this.expect = expect;
			this.number = number;
			this.repeat = repeat;
		}
	}

	public static void main(String[] args) throws InterruptedException {
		long sartTime = System.currentTimeMillis();
		
		//构造生产者实例
		Productor p1 = new Productor(0, 1, 100);
		Productor p2 = new Productor(1, 2, 100);
		Productor p3 = new Productor(2, 3, 100);
		Productor p4 = new Productor(3, 4, 100);

		Productor monitor = new Productor(4, 0, 100);

		//构造所有消费者实例
		Consumer consumer = new Consumer();
		//创建并启动消费者线程
		Thread tConsumer = new Thread(consumer);
		tConsumer.start();

		//等待消费者启动完毕
		while (!consumer.isStarted.get()) {
			Thread.yield();
		}
		
		//启动所有生产者
		new Thread(p1).start();
		new Thread(p2).start();
		new Thread(p3).start();
		new Thread(p4).start();

		new Thread(monitor).start();
		
		//等待生产者执行完毕
		latch.await();
		//让消费者进行最后一次消费
		syncLock.lock();
		consumeCondition.signalAll();
		syncLock.unlock();
		//等待消费者执行完毕
		tConsumer.join();
		
		long endTime = System.currentTimeMillis();
		
		System.out.println("\n执行完毕，耗时 " + (endTime - sartTime) + "ms.");
	}
}

输出：

1234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234123412341234
执行完毕，耗时 31ms.

当然，这种实现有一个问题，就是会造成storge部分空间浪费（为了维持状态的稳定），以及会多创建一个用来重置状态的monitor生产者。但是这种方式的锁代价相对比较小，执行速度也会比严格同步要快。 如果有好的建议，欢迎提出~

[baibaishen.csdn]

之前没有太多思路，看了您的回答豁然开朗（本人菜鸟级别），谢谢交流学习！