生产者和消费者 用Semaphore来控制线程

package org.java.Thread;


import java.util.concurrent.Semaphore;


public class MultiThread {
//定义一个仓库的容量
private final int MAX_SIZE = 100;
//定义一个显著仓库的商品的数量
private int current;

//用信号量来控制
Semaphore semaphore = new Semaphore(1);

//数据仓库的构造方法
//初始化他的现在库存量
public MultiThread(int current){
this.current = current;
}

//仓库是一个共享资源，所以定义两个方法，存放商品和销售商品

public void produce(int produceNum){
//下面要获得这个仓库的许可才可以运行
try {
semaphore.acquire();
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
//获得生产者的名字
String name = Thread.currentThread().getName();
while((current+produceNum)>MAX_SIZE){

System.out.println("仓库现在的商品量是："+current+","+name+"不能把自己生产的"+produceNum+"个商品放入仓库了,不然就爆仓了");
//倘若没有获得这个任务不能在这个时候执行任务，那么他只能挂起
//可是挂起，有不释放资源就会死锁，所以就要释放资源
//可是这个线程都要每次去检查自己去检查自己满足条件了吗？
//当满足的时候，就跳出循环，当不满足，就去跟其他线程抢acquire这个许可。
semaphore.release();

try {
//为什么要休眠10秒，因为自己不满足条件，不要那么那么快就去抢资源
//抢来了，仓库也放不了生产的商品
Thread.sleep(10);
//在这里挂起，等待得到资源，和其他线程一样，抢资源
semaphore.acquire();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
current += produceNum;
System.out.println(name+"把自己生产的"+produceNum+"个商品放入仓库中！");
System.out.println("现在仓库的商品量是："+current);
//执行完，就释放许可
semaphore.release();


}

//销售商品
public  void reduce(int reduceNum){
//下面要获得这个仓库的许可才可以运行
try {
semaphore.acquire();
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
String name = Thread.currentThread().getName();
while((current-reduceNum)<0){
System.out.println("仓库现在的商品量是："+current+","+name+"不能从仓库拿走"+reduceNum+"个商品");
semaphore.release();
try {
Thread.sleep(10);
semaphore.acquire();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
/*try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}*/
}
current -= reduceNum;
System.out.println(name+"从仓库中拿走了"+reduceNum+"个商品！");
System.out.println("现在仓库的商品量是："+current);
semaphore.release();

}

public static void main(String[] args){
MultiThread mul = new MultiThread(30);
Producer p1 = new Producer("p1",10,mul);
Producer p2 = new Producer("p2",20,mul);
Producer p3 = new Producer("p3",30,mul);
Producer p4 = new Producer("p4",40,mul);
Producer p5 = new Producer("p5",50,mul);
Consumer c1 = new Consumer("c1",20,mul);
Consumer c2 = new Consumer("c2",30,mul);
Consumer c5 = new Consumer("c5",50,mul);
Consumer c3 = new Consumer("c3",40,mul);
Consumer c4 = new Consumer("c4",40,mul);

p1.start();
p2.start();
p3.start();
p4.start();
p5.start();
c1.start();
c2.start();
c3.start();
c4.start();
c5.start();

}
}


class Producer extends Thread{
//生产的商品个数
private int produceNum;
private String name;
private MultiThread multiThread;


public Producer(String name,int produceNum, MultiThread multiThread) {
super(name);
this.name = name;
this.produceNum = produceNum;
this.multiThread = multiThread;
}

public void run(){
System.out.println(name+"打算把最近生产的"+produceNum+"个商品放入仓库中");
multiThread.produce(produceNum);
}
}


class Consumer extends Thread{
//生产的商品个数
private int reduceNum;
private String name;
private MultiThread multiThread;


public Consumer(String name,int reduceNum, MultiThread multiThread) {
super(name);
this.name = name;
this.reduceNum = reduceNum;
this.multiThread = multiThread;
}

public void run(){
System.out.println(name+"准备去仓库里拿走"+reduceNum+"个商品");
multiThread.reduce(reduceNum);
}
}