使用锁模拟写一个固定容量同步容器(马士兵并发笔记)

写一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持多个生产者和多个消费者线程拥塞调用。

1.使用synchronized锁或ReentrantLock锁实现

1）使用synchronized锁的notify、notifyAll来实现

基本思路：使用put方法向容器中添加元素，使用get方法从容器中取出元素，在使用put方法添加元素的时候进行判断，如果容器已经满了，此时调用wait()方法，使用添加线程阻塞，等待消费线程取出元素，腾出容器空间后才能再向其中添加元素，同理当使用get方法获取元素的时候，如果同期已经为空，此时要调用wait()方法，使得取出线程阻塞，等待添加线程添加元素，容器有值后才能再从容器中取出元素。

public class MyContainer1<T> {
	final private LinkedList<T> lists = new LinkedList<>();
	final private int MAX = 10; //最多10个元素
	private int count = 0;
	
	
	public synchronized void put(T t) {
		while(lists.size() == MAX) { //想想为什么用while而不是用if？
			try {
				this.wait(); //effective java
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		lists.add(t);
		++count;
		System.out.println("生产者容器中的物品数: "+count);
		this.notifyAll(); //通知消费者线程进行消费
	}
	
	public synchronized T get() {
		T t = null;
		while(lists.size() == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		t = lists.removeFirst();
		count --;
		System.out.println("消费者容器中的物品数: "+count);
		this.notifyAll(); //通知生产者进行生产
		return t;
	}
	
	public static void main(String[] args) {
		MyContainer1<String> c = new MyContainer1<>();
		//启动消费者线程
		for(int i=0; i<10; i++) {
			new Thread(()->{
				for(int j=0; j<5; j++) 	//生产者执行了50次
					c.get();
					//System.out.println(c.get());
			}, "c" + i).start();
		}
		
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		//启动生产者线程
		for(int i=0; i<2; i++) {
			new Thread(()->{
				for(int j=0; j<25; j++) 	//消费者执行了50次
					c.put(Thread.currentThread().getName() + " " + j);
			}, "p" + i).start();
		}
	}
}

public static void main(String[] args) {MyContainer1<String> c = new MyContainer1<>();//启动消费者线程for(int i=0; i<10; i++) {new Thread(()->{for(int j=0; j<5; j++) //生产者执行了50次c.get();//System.out.println(c.get());}, "c" + i).start();}try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}//启动生产者线程for(int i=0; i<2; i++) {new Thread(()->{for(int j=0; j<25; j++) //消费者执行了50次c.put(Thread.currentThread().getName() + " " + j);}, "p" + i).start();}}}

说明：如下的代码中应当注意三点：

        第一点：在count--后，this.notifyAll()的作用是处理这样一种情况：如果容器满了，此时生产者线程被阻塞，这是消费者线程消费了元素后，注意要唤醒生产者线程，如果没有这一步，那么只有消费者线程执行，消费者线程都执行完或者执行到容量为空时，此时会出现生成者线程一直被阻塞等待锁的情况，此时程序将停留在这里。

        第二点：注意这里的while(lists.size()==0)不能换成if(lists.size())==0，分析：考虑这样一种情况，容器为空，消费线程t1和t2调用wait()方法进入阻塞，此时生产线程t3生产了一个元素后，唤醒所有的线程后，此时线程t1从this.wait()后面直接执行，消费一个元素后，线程t2从this.wait()后的代码直接执行，并不会判断，此时容器已经为空，但它依旧取出一个元素，导致了报错。

        第三点：this.notifyAll()不能换成this.notify()，因为如果换成this.notify()函数，此时只唤醒一个线程，假设这样一种状态，消费者线程消费了最后一个元素后，容器为空，此时消费者线程本打算唤醒生产者线程，结果却唤醒了消费者线程，消费者线程在执行了while(lists.size()==0)中的this.wait()方法后进入阻塞状态，此时被唤醒的消费者线程也进入阻塞状态，程序死锁。

2）使用ReentrantLock锁的notify、notifyAll来实现

public class MyContainer2<T> {
	final private LinkedList<T> lists = new LinkedList<>();
	final private int MAX = 10; //最多10个元素
	private int count = 0;
	
	private Lock lock = new ReentrantLock();
	private Condition producer = lock.newCondition();
	private Condition consumer = lock.newCondition();
	
	public void put(T t) {
		try {
			lock.lock();
			while(lists.size() == MAX) { //想想为什么用while而不是用if？
				producer.await();		//当消费者线程们执行到这里的时候等待
			}
			
			lists.add(t);
			++count;
			System.out.println("里面有个数："+count);
			consumer.signalAll(); //通知消费者线程进行消费
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public T get() {
		T t = null;
		try {
			lock.lock();
			while(lists.size() == 0) {
				consumer.await();	//当生产者线程执行到这里的等待
			}
			t = lists.removeFirst();
			count --;
			System.out.println("里面有个数："+count);
			producer.signalAll(); //通知生产者的线程们进行生产
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
		return t;
	}
	
	public static void main(String[] args) {
		MyContainer2<String> c = new MyContainer2<>();
		//启动消费者线程
		for(int i=0; i<10; i++) {
			new Thread(()->{
				for(int j=0; j<5; j++) 
					c.get();
					//System.out.println(c.get());
			}, "c" + i).start();
		}
		
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		//启动生产者线程
		for(int i=0; i<2; i++) {
			new Thread(()->{
				for(int j=0; j<25; j++) 
					c.put(Thread.currentThread().getName() + " " + j);
			}, "p" + i).start();
		}
	}
}

说明：ReentrantLock锁的好处，可以创建多个Condition队列，如上面的代码，创建了consumer和producer队列，在get方法中会将执行该方法的消费者线程通过consumer.await()方法阻塞consumer队列中，同时在get方法中可以只唤醒consumer(生产者)队列的线程。

2.直接使用BlockingQueue实现

1）BlockingQueue是一个接口，并非具体实现，常见的BlockingQueue实现有ArrayBlockingQueue和LinkedBlockingQueue。ArrayBlockingQueue是基于数组实现，而LinkedBlockingQueue是基于链表实现。

2）向队列中压入元素课可以使用offer()方法和put()方法，对于offer()方法，如果队列已经满了，它就会立即返回false，如果没有满，则执行正常的入队列操作，而put()方法，如果队列满了，它会一直等待，直到队列中有空闲的位置。

3）从队列中弹出元素，可以使用poll()方法和take()方法，如果队列为空poll()方法直接返回null，而take()方法会一直等待，直到队列内有可用元素。

4）put()方法和take()方法体现Blocking的关键。

使用LinkedBlockingQueue实现上面的固定同步容器代码如下：

public class TestBlockingQueue<T> {  
    //final private LinkedList<T> lists = new LinkedList<>();
	BlockingQueue<T> queue = new LinkedBlockingDeque<>(10);
	     
    //生产者线程
    public void put(T t) {  
        try {  
            queue.put(t);  
            System.out.println("里面有个数："+queue.size());  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
      
    public T get() {  
        T t = null;  
            try {
				queue.take();
				System.out.println("里面有个数："+queue.size());  
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
            
        return t;  
    }  
      
    public static void main(String[] args) {  
        TestBlockingQueue<String> c = new TestBlockingQueue<>();  
        //启动消费者线程  
        for(int i=0; i<10; i++) {  
            new Thread(()->{  
                for(int j=0; j<5; j++)   
                    c.get();  
                    //System.out.println(c.get());  
            }, "c" + i).start();  
        }  
          
        try {  
            TimeUnit.SECONDS.sleep(2);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
          
        //启动生产者线程  
        for(int i=0; i<2; i++) {  
            new Thread(()->{  
                for(int j=0; j<25; j++)   
                    c.put(Thread.currentThread().getName() + " " + j);  
            }, "p" + i).start();  
        }  
    }  
}