生产者/消费者模式实现(2)

基本思路：

基于java自带的可重入锁和条件量实现基本的有限缓冲区生产者消费者模式

代码如下：

package ConcurrentControl;

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

/**
 有限缓冲区的生产者消费者模式（简单模拟）
 实现方式2
 采用可重入锁实现
 */
public class Problem_02 {
    private static final Lock lock = new ReentrantLock();
    private static final Condition notFull = lock.newCondition();
    private static final Condition notEmpty = lock.newCondition();
    private static final int buffSize = 10;
    private static int availableSlotNum = 0;

    public static void main(String argv[]){
        new Thread(new Producer()).start();
        new Thread(new Consumer()).start();
        new Thread(new Producer()).start();
        new Thread(new Consumer()).start();
        new Thread(new Producer()).start();
        new Thread(new Consumer()).start();
        new Thread(new Producer()).start();
        new Thread(new Consumer()).start();
    }

    private  static class Producer implements  Runnable{
        @Override
        public void run() {
            for(int i=0; i<10; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.lock();
                try {
                    while(availableSlotNum==buffSize){
                        notFull.await();
                    }
                    availableSlotNum++;
                    System.out.printf("********************\n");
                    System.out.printf("Producer:\n");
                    System.out.printf("\tThread Name -> " + Thread.currentThread().getName()+"\n");
                    System.out.printf("\tAvailableSlotNum -> " + availableSlotNum+"\n");
                    System.out.printf("********************\n");
                    notEmpty.signalAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    private  static class Consumer implements  Runnable{
        @Override
        public void run() {
            for(int i=0; i<10; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.lock();
                try {
                    while(availableSlotNum==0){
                        notEmpty.await();
                    }
                    availableSlotNum--;
                    System.out.printf("********************\n");
                    System.out.printf("Consumer:\n");
                    System.out.printf("\tThread Name -> " + Thread.currentThread().getName()+"\n");
                    System.out.printf("\tAvailableSlotNum -> " + availableSlotNum+"\n");
                    System.out.printf("********************\n");
                    notFull.signalAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
}