java中阻塞与非阻塞队列主要方法差异

测试java，阻塞和非阻塞队列几个添加，删除，检查方法。

代码与解释如下：

import org.junit.Test;

import java.util.NoSuchElementException;
import java.util.Queue;
import java.util.concurrent.*;

public class QueueTest
{
    @Test
    //测试队列，方便起见，测试使用有界队列,无界队列，
    //如ArrayList、DelayQueue的实现无法使add方法抛出IllegalStateException异常
    //而是直接出现OutOfMemoryError错误
    public void queueTest()
    {
//              抛出异常 	返回特殊值
//      插入 	add(e)      offer(e)
//      移除 	remove() 	poll()
//      检查 	element() 	peek()

//      建立了一个长度为5的空阻塞有界队列，数组实现
        Queue<Integer> queue = new LinkedBlockingQueue<>(5);

        System.out.println("用add()方法填充满此队列，需要使用try..catch..\n" + queue);
        int i = 0;
        while (true)
        {
            try
            {
                queue.add(i);
                System.out.println(queue);
                i++;
                sleepOneSecond();
            }
            catch (IllegalStateException e)
            {
                e.printStackTrace();
                break;
            }
        }
        System.out.println();

        sleepOneSecond();
        System.out.println("用remove()方法消费此队列，需要使用try..catch..\n" + queue);
        while (true)
        {
            try
            {
                queue.remove();
                System.out.println(queue);
                sleepOneSecond();
            }
            catch (Exception e)
            {
                e.printStackTrace();
                break;
            }
        }
        System.out.println();

        sleepOneSecond();
        System.out.println("用offer()方法填充此队列，需要使用只需要判断返回值\n" + queue);
        int k = 0;
        while (queue.offer(k))
        {
            k++;
            System.out.println(queue);
            sleepOneSecond();
        }
        System.out.println();

        sleepOneSecond();
        System.out.println("poll()方法消费此队列，只需要判断取出值是否为null即可\n" + queue);
        while (queue.poll() != null)
        {
            System.out.println(queue);
            sleepOneSecond();
        }
        System.out.println();

        sleepOneSecond();
        System.out.println("尝试拿到一个空队列的队列头，peek方法拿到null：" + queue.peek());
        System.out.println();

        sleepOneSecond();
        try
        {
            System.out.println("尝试拿到一个空队列的队列头，element方法抛出异常NoSuchElementException：");
            sleepOneSecond();
            System.out.println(queue.element());
        }
        catch (NoSuchElementException e)
        {
            e.printStackTrace();
        }
    }


    private static void sleepOneSecond()
    {
        try
        {
            Thread.sleep(1000);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }


    //                  抛出异常 	特殊值 	    阻塞 	超时
    //        插入 	    add(e) 	    offer(e) 	put(e) 	offer(e, time, unit)
    //        移除 	    remove() 	poll() 	    take() 	poll(time, unit)
    //        检查 	    element() 	peek() 	    不可用 	不可用

    @Test
    public void testBlockingQueue() throws InterruptedException
    {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);

        new Thread(() ->
        {
            try
            {
                for (int i = 0; i < 11; i++)
                {
                    queue.put(i);
                    System.out.println(Thread.currentThread().getName() + queue);
                    sleepOneSecond();
                }
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }, "provider").start();


        TimeUnit.SECONDS.sleep(15);

        new Thread(() ->
        {
            System.out.println("消费者线程启动");
            try
            {
                for (int i = 0; i < 15; i++)
                {
                    queue.take();
                    System.out.println((Thread.currentThread().getName() +queue));
                    sleepOneSecond();
                }
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }, "consumer").start();

        //junit测试在主线程结束之后，其他线程都会直接结束
        //故此休眠25s,推荐使用CountDownLatch,此处简单处理
        TimeUnit.SECONDS.sleep(25);
    }
}

附上集合/容器类的uml类图，包括同步类。