一个基于链接节点的无界线程安全队列。此队列按照 FIFO（先进先出）原则对元素进行排序。队列的头部 是队列中时间最长的元素。队列的尾部 是队列中时间最短的元素。
新的元素插入到队列的尾部，队列获取操作从队列头部获得元素。当多个线程共享访问一个公共 collection 时，ConcurrentLinkedQueue 是一个恰当的选择。此队列不允许使用 null 元素。

public static void main(String[] args) { 
        ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue(); 
        queue.offer("哈哈哈"); 
        System.out.println("offer后，队列是否空？" + queue.isEmpty()); 
        System.out.println("从队列中poll：" + queue.poll()); 
        System.out.println("pool后，队列是否空？" + queue.isEmpty()); 
    }

offer后，队列是否空？false 
从队列中poll：哈哈哈 
pool后，队列是否空？true

public static void main(String[] args) { 
        ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue(); 
        queue.offer("哈哈哈"); 
        System.out.println("offer后，队列是否空？" + queue.isEmpty()); 
        System.out.println("从队列中peek：" + queue.peek()); 
        System.out.println("从队列中peek：" + queue.peek()); 
        System.out.println("从队列中peek：" + queue.peek()); 
        System.out.println("pool后，队列是否空？" + queue.isEmpty()); 
    }

offer后，队列是否空？false 
从队列中peek：哈哈哈 
从队列中peek：哈哈哈 
从队列中peek：哈哈哈 
pool后，队列是否空？false

public static void main(String[] args) { 
        ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue(); 
        queue.offer("哈哈哈"); 
        System.out.println("offer后，队列是否空？" + queue.isEmpty()); 
        System.out.println("从队列中remove已存在元素 ：" + queue.remove("哈哈哈")); 
        System.out.println("从队列中remove不存在元素：" + queue.remove("123")); 
        System.out.println("remove后，队列是否空？" + queue.isEmpty()); 
    }

offer后，队列是否空？false 
从队列中remove已存在元素 ：true 
从队列中remove不存在元素：false 
remove后，队列是否空？true

如果此队列包含的元素数大于 Integer.MAX_VALUE，则返回 Integer.MAX_VALUE。 
需要小心的是，与大多数 collection 不同，此方法不是 一个固定时间操作。由于这些队列的异步特性，确定当前的元素数需要进行一次花费 O(n) 时间的遍历。
所以在需要判断队列是否为空时，尽量不要用 queue.size()>0，而是用 !queue.isEmpty()

public class Test01ConcurrentLinkedQueue { 
    public static void main(String[] args) throws InterruptedException { 
        int peopleNum = 10000;//吃饭人数 
        int tableNum = 10;//饭桌数量 
 
        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>(); 
        CountDownLatch count = new CountDownLatch(tableNum);//计数器 
 
        //将吃饭人数放入队列（吃饭的人进行排队） 
        for(int i=1;i<=peopleNum;i++){ 
            queue.offer("消费者_" + i); 
        } 
        //执行10个线程从队列取出元素（10个桌子开始供饭） 
        System.out.println("-----------------------------------开饭了-----------------------------------"); 
        long start = System.currentTimeMillis(); 
        ExecutorService executorService = Executors.newFixedThreadPool(tableNum); 
        for(int i=0;i<tableNum;i++) { 
            executorService.submit(new Dinner("00" + (i+1), queue, count)); 
        } 
        //计数器等待，知道队列为空（所有人吃完） 
        count.await(); 
        long time = System.currentTimeMillis() - start; 
        System.out.println("-----------------------------------所有人已经吃完-----------------------------------"); 
        System.out.println("共耗时：" + time); 
        //停止线程池 
        executorService.shutdown(); 
    } 
 
    private static class Dinner implements Runnable{ 
        private String name; 
        private ConcurrentLinkedQueue<String> queue; 
        private CountDownLatch count; 
 
        public Dinner(String name, ConcurrentLinkedQueue<String> queue, CountDownLatch count) { 
            this.name = name; 
            this.queue = queue; 
            this.count = count; 
        } 
 
        @Override 
        public void run() { 
            //while (queue.size() > 0){ 
            while (!queue.isEmpty()){ 
                //从队列取出一个元素 排队的人少一个 
                System.out.println("【" +queue.poll() + "】----已吃完...， 饭桌编号：" + name); 
            } 
            count.countDown();//计数器-1 
        } 
    } 
}

public static void main(String[] args) throws InterruptedException { 
        ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue(); 
        queue.offer("123"); 
        System.out.println(queue.contains("123")); 
        System.out.println(queue.contains("234")); 
    }

public static void main(String[] args) throws InterruptedException { 
        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>(); 
        queue.offer("123"); 
        queue.offer("234"); 
        Object[] objects = queue.toArray(); 
        System.out.println(objects[0] + ", " + objects[1]); 
 
        //将数据存储到指定数组 
        String[] strs = new String[2]; 
        queue.toArray(strs); 
        System.out.println(strs[0] + ", " + strs[1]); 
    }

public static void main(String[] args) throws InterruptedException { 
        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>(); 
        queue.offer("123"); 
        queue.offer("234"); 
        Iterator<String> iterator = queue.iterator(); 
        while (iterator.hasNext()){ 
            System.out.println(iterator.next()); 
        } 
    }