面试系列----阻塞队列

面试系列----阻塞队列

0.什么是阻塞队列

阻塞队列,顾名思义,首先它是一个队列,而一个阻塞队列在数据结构中所起的作用大致如图所示:

当阻塞队列为空时，从队列中获取元素的操作会被阻塞。

当阻塞队列是满时，往队列中添加元素的操作会被阻塞。

在多线程领域，所谓阻塞，在某些情况下会挂起线程(即线程阻塞)，一旦条件满足,被挂起的线程会被被自动唤醒

使用阻塞队列的好处：我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为阻塞队列已经将这事情解决了。在concurrent包发布之前，在多线程的环境下，每个程序员都必须自己去控制这些细节，尤其是兼顾效率和线程安全，给我们的编程带来很大的复杂。

1.阻塞队列的使用

在concurrent包下有这么一个接口为BlockingQueue即为java实现的阻塞队列，他有很多的实现类，其父接口为Collection

下面是BlockingQueue的实现类

ArrayBlockingQueue：有数组结构组成的有界阻塞队列。

LinkedBlockingDeque：有链表结构组成的有界（默认大小为Integer.MAX_VALUE）阻塞队列。

PriorityBlockingQueue:支持优先级排序的无界阻塞队列。

DelayQueue: 使用优先级队列实现的延迟无界阻塞队列。

SynchronousQueue:不存储元素的阻塞队列,也即是单个元素的队列。SynchronousQueue是一个不存储元素的BlcokingQueue，每个put操作必须要等待一个take操作,否则不能继续添加元素,反之亦然.

LinkedTransferQueue:由链表结构组成的无界阻塞队列.

LinkedBlockingDeque:由链表结构组成的双向阻塞队列.

在BlockingQueue中有几个常见的方法：

类型
抛出异常	当阻塞队列满时,再往队列里面add插入元素会抛IllegalStateException: Queue full 当阻塞队列空时,再往队列Remove元素时候回抛出NoSuchElementException
特殊值	插入方法,成功返回true 失败返回false 移除方法,成功返回元素,队列里面没有就返回null
一直阻塞	当阻塞队列满时,生产者继续往队列里面put元素,队列会一直阻塞直到put数据or响应中断退出 当阻塞队列空时,消费者试图从队列take元素,队列会一直阻塞消费者线程直到队列可用.
超时退出	当阻塞队列满时,队列会阻塞生产者线程一定时间,超过后限时后生产者线程就会退出

简单用阻塞队列实现一个生产者和消费者的例子

class Myresource {

    private volatile boolean flag = true;
    private AtomicInteger atomicInteger = new AtomicInteger(0);

    private BlockingQueue<String> blockingQueue = null;

    public Myresource(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
        System.out.println(blockingQueue.getClass().getName());

    }

    public void myProd() throws Exception {

        String data = null;
        boolean result;
        while (flag) {

            data = atomicInteger.incrementAndGet() + "";
            result = blockingQueue.offer(data, 2L, TimeUnit.SECONDS);
            if (result) {
                System.out.println(Thread.currentThread().getName() + "\t 插入队列数据" + data + "成功");
            } else {
                System.out.println(Thread.currentThread().getName() + "\t 插入队列数据" + data + "失败");
            }
            TimeUnit.SECONDS.sleep(1);
        }

        System.out.println(Thread.currentThread().getName() + "\t 停止 表示 flag=" + flag);

    }

    public void myConsumer() throws Exception{
        String result = null;
        while (flag){
            result = blockingQueue.poll(2L, TimeUnit.SECONDS);
            //TimeUnit.SECONDS.sleep(1);
            if (null == result || "".equalsIgnoreCase(result)) {
                flag = false;
                System.out.println(Thread.currentThread().getName()+"\t"+"超过2m没有取到 消费退出");
                System.out.println();
                System.out.println();
                System.out.println();
                return;

            }
            System.out.println(Thread.currentThread().getName() + "消费队列" + result + "成功");
        }

    }

    public void stop(){
        flag = false;
    }


}

public class ProdConsumerBlockQueueDemo {

    public static void main(String[] args) {
        Myresource myresource = new Myresource(new ArrayBlockingQueue<>(10));

        new Thread(() ->{
            System.out.println(Thread.currentThread().getName()+"\t生产线程启动");

            try {
                myresource.myProd();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"produce").start();


        new Thread(() ->{
            System.out.println(Thread.currentThread().getName()+"\t消费线程启动");
            System.out.println();
            System.out.println();
            System.out.println();

            try {
                myresource.myConsumer();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"comsumer").start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println("时间到,停止活动");
        myresource.stop();

    }

}