LinkedBlockingQueue应该是比较常用的队列了。

阻塞队列的基本方法：

add 增加一个元索如果队列已满，则抛出一个IIIegaISlabEepeplian异常

remove 移除并返回队列头部的元素如果队列为空，则抛出一个 NoSuchElementException异常

element返回队列头部的元素如果队列为空，则抛出一个NoSuchElementException异常

offer添加一个元素并返回true如果队列已满，则返回false

poll移除并返问队列头部的元素如果队列为空，则返回null

peek返回队列头部的元素如果队列为空，则返回null

put添加一个元素如果队列满，则阻塞

take移除并返回队列头部的元素如果队列为空，则阻塞

示例：

package yxxy.queuue;

import java.util.Arrays;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class TEST {
    
    public static void main(String[] args) throws Exception {
        
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        
        Thread[] ths = new Thread[6];
        for(int i=0;i<ths.length-1;i++){
            Runnable task = new Runnable() {
                
                @Override
                public void run() {
                    while(true){
                        try {
                            int i = queue.poll(1, TimeUnit.SECONDS);
                        } catch (Exception e) {
                            System.out.println("err");
                            break;
                        }
                    }
                }
                
            };
            ths[i] = new Thread(task);
        }
        Runnable task = new Runnable() {
            
            @Override
            public void run() {
                for(int i=0;i<99999;i++){
                    try {
                        queue.put(i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            
        };
        ths[5] = new Thread(task);
        long a = System.currentTimeMillis();
        runAndComputeTime(ths);
        long b = System.currentTimeMillis();
        System.out.println(b-a);
    }
    
    
    static void runAndComputeTime(Thread[] ths) {
        Arrays.asList(ths).forEach(t->t.start());
        Arrays.asList(ths).forEach(t->{
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
    }
}