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