标签：Java 入门 void new Assert ArrayBlockingQueue arrayBlockingQueue public MyElement

ArrayBlockingQueue：

一个阻塞队列，注意只要有Blocking，都是阻塞的，要阻塞，那容量必须是固定的，在构造方法中指定数量.
如果已经Full，那么put操作会一直等待有空位置出来。
如果已经Empty，那么take会一直等有新元素进来.

示例代码

package com.abc.test;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;


/**
 * 注意：以下测试用例只能单独执行.
 */
public class ArrayBlockingQueueTest {

    public static class MyElement {
        final int order;
        final String name;

        public MyElement(String name, int order) {
            this.name = name;
            this.order = order;
        }
    }

    ArrayBlockingQueue<MyElement> arrayBlockingQueue = new ArrayBlockingQueue<>(5);

    //注意线程池数目不能设置为1个.
    ExecutorService pools = Executors.newFixedThreadPool(10);

    /**
     * 先准备5个元素，供每个测试用例使用.
     */
    @Before
    public void init() {
        arrayBlockingQueue.add(new MyElement("1", 1));
        arrayBlockingQueue.add(new MyElement("3", 3));
        arrayBlockingQueue.add(new MyElement("5", 5));
        arrayBlockingQueue.add(new MyElement("10", 10));
        arrayBlockingQueue.add(new MyElement("15", 15));
    }

    /**
     * 只能放5个元素,继续add会报错.
     */
    @Test(expected = IllegalStateException.class)
    public void testFullAndAdd() {
        arrayBlockingQueue.add(new MyElement("16", 16));
    }

    /**
     * 只能放5个元素,offer不成功会返回false.
     */
    @Test
    public void testFullAndOffer() {
        Assert.assertFalse(arrayBlockingQueue.offer(new MyElement("16", 16)));
    }

    /**
     * poll.
     */
    @Test
    public void testPoll() throws InterruptedException {
        MyElement element = arrayBlockingQueue.poll();
        Assert.assertEquals(element.order, 15);
        Assert.assertEquals(arrayBlockingQueue.size(), 4);
        MyElement element2 = arrayBlockingQueue.poll();
        Assert.assertEquals(element2.order, 1);
        Assert.assertEquals(arrayBlockingQueue.size(), 3);
    }

    /**
     * put的时候如果已经full会等待有多余位置出来.
     */
    @Test
    public void testFullAndPut() throws InterruptedException {
        pools.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    arrayBlockingQueue.put(new MyElement("16", 16));
                    System.out.println("after put");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        pools.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000 * 5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                arrayBlockingQueue.poll();
                System.out.println("after poll");
            }
        });

        Thread.sleep(2000);
        {
            MyElement[] array = new MyElement[5];
            arrayBlockingQueue.toArray(array);
            MyElement last = array[array.length - 1];
            Assert.assertEquals(last.order, 15);
        }
        pools.awaitTermination(8, TimeUnit.SECONDS);
        {
            MyElement[] array = new MyElement[5];
            arrayBlockingQueue.toArray(array);
            MyElement last = array[array.length - 1];
            Assert.assertEquals(last.order, 16);
        }

        MyElement element = arrayBlockingQueue.poll();
        Assert.assertEquals(element.order, 3);
        Assert.assertEquals(arrayBlockingQueue.size(), 4);
    }

    /**
     * take如果为空会等待.
     */
    @Test
    public void testTake() throws InterruptedException {
        arrayBlockingQueue.clear();
        pools.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    MyElement element = arrayBlockingQueue.take();
                    Assert.assertEquals(element.order, 100);
                    System.out.println("after put");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        pools.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    arrayBlockingQueue.put(new MyElement("100", 100));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        pools.awaitTermination(8, TimeUnit.SECONDS);
    }

}

标签：Java,入门,void,new,Assert,ArrayBlockingQueue,arrayBlockingQueue,public,MyElement
来源： https://blog.csdn.net/oHeHui1/article/details/122052560

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。