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

基本思路：

基于简单的synchronized获取对锁实现对临界计数器的互斥访问，再使用Object对象中的wait/notifiy是的进程在被设定为lock的对象上等待，实现了简单了有限缓冲区的生产者/消费者模式。

代码如下：

package ConcurrentControl;
/**
 有限缓冲区的生产者消费者模式（简单模拟）
 实现方式1
 用synchronized获取对象锁
 */
public class Problem_01 {
    private static final int buffSize = 10;
    private static int availableSlotNum = 0;
    private static final Object lockObj = new Object();

    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();
                }
                synchronized (lockObj){
                    while(availableSlotNum==buffSize){
                        try {
                            lockObj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    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");
                    lockObj.notifyAll();
                }
            }
        }
    }

    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();
                }
                synchronized (lockObj){
                    while(availableSlotNum==0){
                        try {
                            lockObj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    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");
                    lockObj.notifyAll();
                }
            }
        }
    }
}