多线程--生产者和消费者

生产者-消费者问题：

生产者向产品区里放产品，当产品区里满了，需要等待；消费者从产品区里取产品消耗，当产品区里空了，需要等待。

public class ProducerAndConsumer
{
//创建缓冲区
private static Buffer buffer = new Buffer();

public static void main(String[] args)
{
System.out.println("Hello World!");
Thread producer = new Thread(new Producer());
Thread consumer = new Thread(new Consumer());
consumer.start();
producer.start();

}

//消费者
static class Consumer implements Runnable
{
public void run(){
try{
while(true){
buffer.poll();
Thread.sleep((int)(Math.random()*1000));
}
}catch(InterruptedException ex){}
}
}
//生产者
static class Producer implements Runnable
{
public void run(){
try{
while(true){
buffer.push(new Random().nextInt(20));
Thread.sleep((int)(Math.random()*1000));
}
}catch(InterruptedException ex){}
}
}
}

//缓冲池
class Buffer
{
//创建锁
private static Lock lock = new ReentrantLock();
//条件1---缓冲池空
private static Condition empty = lock.newCondition();
//条件2---缓冲池满
private static Condition full = lock.newCondition();
//缓冲池大小
private static final int  size =  10;
//缓冲池
private Queue<Integer> queue = new LinkedList<Integer>();

//取数
public void poll(){
lock.lock();
try{
while(queue.size() == 0){
System.out.println("\t\t\t\tWait for producer:");
empty.await();
}
int num = queue.poll();
System.out.println("\t\t\t\t["+queue.size()+"]poll:" + num);
full.signal();
}catch(InterruptedException ex){

}finally{
lock.unlock();
}

}
//存数
public void push(int num){
lock.lock();
try{
while(queue.size() == 10){
System.out.println("Wait for consumer:");
full.await();
}
queue.offer(num);
System.out.println("["+queue.size()+"]push:" + num);
empty.signal();
}catch(InterruptedException ex){

}finally{
lock.unlock();
}
}
}

多个生产者-多个消费者问题

由于产品区是互斥访问的，一次只有一个线程能够进入产品区，所以和上面的几乎一样，只是多加一个进程（不知道理解的是否对）