java并发编程之使用Semaphore实现多生产者/多消费者模式

版权声明：前半生，不害怕；后半生，不后悔！ https://blog.csdn.net/qq_14842117/article/details/89497957

本实验的目的不光是实现生产者与消费者模式，还要限制生产者与消费者的数量，这样代码的复杂性就提高一些，但好在使用Semaphore类实现这个功能还是比较简单的。

package cn.yu.semaphore;

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

public class RepastService {
 volatile private Semaphore setSemaphore= new Semaphore(10);//厨师
 volatile private Semaphore getSemaphore = new Semaphore(20);//就餐者
 volatile private ReentrantLock lock = new ReentrantLock();
 volatile private Condition setCondition = lock.newCondition();
 volatile private Condition getCondition = lock.newCondition();
 //producePosition变量的含义是最多只有4个盒子存放菜品
 volatile private Object[] producePosition = new Object[4];
 private boolean isEmpty() {
	 boolean isEmpty = true;
	 for(int i = 0;i<producePosition.length;i++) {
		 if(producePosition[i]!=null) {
			 isEmpty = false;
			 break;
		 }
	 }
	 if(isEmpty == true) {
		 return true;
	 }else {
		 return false;
	 }
 }
 
 private boolean isFull() {
	 boolean isFull = true;
	 for(int i= 0;i<producePosition.length;i++) {
		 isFull =false;
		 break;
	 }
	 return isFull;
 }
 
 public void set() {
	  try {
		setSemaphore.acquire();//允许同时最多有10个厨师进行生产
		lock.lock();
		while(isFull()) {
			//生产者在等待
			setCondition.await();
		}
		for(int i =0;i<producePosition.length;i++) {
			if(producePosition[i] == null) {
				producePosition[i] ="数据";
				System.out.println(Thread.currentThread().getName()+"生产了"+producePosition[i]);
				break;
			}
		}
		getCondition.signalAll();
		lock.unlock();
	} catch (InterruptedException e) {
		e.printStackTrace();
	}finally {
		setSemaphore.release();
	}
 }
 
  public void get() {
	 try {
		getSemaphore.acquire();//允许同时最多有20个就餐者
		lock.lock();
		while(isEmpty()) {
			//消费者在等待
			getCondition.await();
		}
		for(int i =0;i<producePosition.length;i++) {
			if(producePosition[i]!=null) {
				System.out.println(Thread.currentThread().getName()+"消费了"+producePosition[i]);
				producePosition[i] =null;
				break;
			}
		}
		setCondition.signalAll();
		lock.unlock();
	} catch (InterruptedException e) {
		
		e.printStackTrace();
	}finally {
		getSemaphore.release();
	}
  }
}

package cn.yu.semaphore;
//生产者
 public class ThreadP extends Thread{
 private RepastService service;
 public ThreadP(RepastService service) {
	 super();
	 this.service = service;
 }
 public void run() {
	 service.set();
 }
 
}

package cn.yu.semaphore;
//消费者
public class ThreadC extends Thread{
	private RepastService service;
	public ThreadC(RepastService service) {
		super();
		this.service = service;
	}
   public void run() {
	   service.get();
   }
}

package cn.yu.semaphore;

public class Test {
	public static void main(String[] args) throws InterruptedException {
		RepastService service = new RepastService();
		ThreadP[] arrayP = new ThreadP[60];
		ThreadC[] arrayC = new ThreadC[60];
		for(int i = 0;i<60;i++) {
			arrayP[i] = new ThreadP(service);
			arrayC[i] = new ThreadC(service);
		}
		Thread.sleep(2000);
		for(int i =0;i<60;i++) {
			arrayP[i].start();
			arrayC[i].start();
		}
	}
}

Thread-2生产了数据
Thread-14生产了数据
Thread-5消费了数据
Thread-3消费了数据
Thread-18生产了数据
Thread-4生产了数据
Thread-19消费了数据
Thread-7消费了数据
Thread-8生产了数据
Thread-6生产了数据
Thread-22生产了数据
Thread-0生产了数据
Thread-9消费了数据
Thread-10生产了数据
Thread-11消费了数据
Thread-12生产了数据
Thread-13消费了数据
Thread-15消费了数据
Thread-16生产了数据
Thread-17消费了数据
Thread-1消费了数据
Thread-20生产了数据
Thread-21消费了数据
Thread-30生产了数据
Thread-24生产了数据
Thread-23消费了数据
Thread-25消费了数据