写一个固定容量同步容器，拥有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();
}
}
}