java 多线程 堵塞队列

package thread;

import com.rabbitmq.client.AMQP;
import com.sun.org.apache.bcel.internal.generic.GOTO;

import java.util.Collection;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;

/**
 * 有一个生产者在生产产品，这些产品将提供给若干个消费者去消费
 * 为了使生产者和消费者能并发执行，在两者之间设置一个有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费
 * 所有生产者和消费者都是异步方式运行的，但它们必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经装满产品且尚未被取走的缓冲区中投放产品。
 */
public class Thread2Test {
    static ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(10);
    private static volatile int countLimit = 0;

    private static class ProThread implements Runnable {
        @Override
        public void run() {

            for (;countLimit < 20;countLimit++) {
                TAG:
                try {
                    blockingQueue.put(UUID.randomUUID().toString());
                } catch (InterruptedException e) {
                    break TAG;
                }
            }

        }
    }

    private static class CusThread implements Runnable {
        @Override
        public void run() {
            while (countLimit < 20 || blockingQueue.poll()!=null) {
                String str =blockingQueue.poll();
                if ((null!=str)) System.out.println(str);
            }
        }
    }

    public static void main(String[] args) {
        try {
            ProThread proThread = new ProThread();
            CusThread cusThread = new CusThread();
            CusThread cusThread1 = new CusThread();
            CusThread cusThread2 = new CusThread();
            new Thread(proThread).start();
            new Thread(cusThread).start();
            new Thread(cusThread1).start();
            new Thread(cusThread2).start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}