java数据结构----队列(二)之阻塞队列

最新推荐文章于 2022-06-23 21:53:31 发布

weixin_42232931

最新推荐文章于 2022-06-23 21:53:31 发布

阅读量237

点赞数

分类专栏：数据结构与算法

本文链接：https://blog.csdn.net/weixin_42232931/article/details/104158850

版权

数据结构与算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

参考文章:https://blog.csdn.net/tonywu1992/article/details/83419448

一. 概述

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和阻塞移除方法

1）支持阻塞的插入方法：意思是当队列满时，队列会阻塞住插入元素的线程，直到队列有空位。
2）支持阻塞的移除方法：意思是在队列为空时，获取元素的线程会等待队列变为非空

抛出异常：是指当阻塞队列满时候，再往队列里插入元素，会抛出 IllegalStateException("Queue full") 异常。当队列为空时，从队列里获取元素时会抛出 NoSuchElementException 异常。
返回特殊值：插入方法会返回是否成功，成功则返回 true。移除方法，则是从队列里拿出一个元素，如果没有则返回 null
一直阻塞：当阻塞队列满时，如果生产者线程往队列里 put 元素，队列会一直阻塞生产者线程，直到拿到数据，或者响应中断退出。当队列空时，消费者线程试图从队列里 take 元素，队列也会阻塞消费者线程，直到队列可用。
超时退出：当阻塞队列满时，队列会阻塞生产者线程一段时间，如果超过一定的时间，生产者线程就会退出。

阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器。

java提供了7种阻塞队列:

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

LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。

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

DelayQueue：一个使用优先级队列实现的无界阻塞队列。

SynchronousQueue：一个不存储元素的阻塞队列。

LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。

LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列

二. 几种常用阻塞队列介绍

1.ArrayBlockingQueue

(1) 要点概述

是一个用数组实现的有界阻塞队列。此队列按照先进先出（FIFO）的原则对元素进行排序。默认情况下不保证访问者公平的访问队列，所谓公平访问队列是指阻塞的所有生产者线程或消费者线程，当队列可用时，可以按照阻塞的先后顺序访问队列，即先阻塞的生产者线程，可以先往队列里插入元素，先阻塞的消费者线程，可以先从队列里获取元素.

(2) 代码分析实现

1> ArrayBlockingQueue的构造方法,初始化了put和take函数中使用到的关键成员变量，分别是ReentrantLock和Condition。

public ArrayBlockingQueue(int capacity, boolean fair) {
    this.items = new Object[capacity];
    lock = new ReentrantLock(fair);
    notEmpty = lock.newCondition();
    notFull =  lock.newCondition();
}

ReentrantLock是AQS的子类，其newCondition函数返回的Condition接口实例是定义在AQS类内部的ConditionObject实现类。它可以直接调用AQS相关的函数。

ArrayBlockingQueue中的元素存在公平访问与非公平访问的区别，对于公平访问队列，被阻塞的线程可以按照阻塞的先后顺序访问队列，即先阻塞的线程先访问队列。而非公平队列，当队列可用时，阻塞的线程将进入争夺访问资源的竞争中，也就是说谁先抢到谁就执行，没有固定的先后顺序.通过fair值可以设置公平与非公平阻塞队列,true为创建公平的阻塞队列

2> put方法会在队列末尾添加元素，如果队列已经满了，无法添加元素的话，就一直阻塞等待到可以加入为止

public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly(); //先获得锁
    try {
        while (count == items.length) 
        //如果队列满了，就NotFull这个Condition对象上进行等待
            notFull.await();
        enqueue(e);
    } finally {
        lock.unlock();
    }
}
private void enqueue(E x) {
    final Object[] items = this.items;
    items[putIndex] = x;
    //这里可以注意的是ArrayBlockingList实际上使用Array实现了一个环形数组，
   //当putIndex达到最大时，就返回到起点，继续插入,
   //当然，如果此时0位置的元素还没有被取走，
   //下次put时，就会因为cout == item.length未被阻塞。
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
    //因为插入了元素，通知等待notEmpty事件的线程。
    notEmpty.signal();
}

我们会发现put方法使用了wait/notify的机制。与一般生产者-消费者的实现方式不同，同步队列使用ReentrantLock和Condition相结合的先获得锁，再等待的机制；通过ReentrantLock结合内部类Condition实现锁机制

ReentrantLock + Condition ≈ Synchronized + Object.wait()/notify()

Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法.不同的是, 同一个锁可以有多个 Condition, 提供多种情况的互不干扰的控制.

3> take方法在队列为空时会被阻塞，一直到阻塞队列加入了新的元素,此时会调用dequeue方法,该方法上的notFull.signal()会通知正在等待的线程。

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0){
            //如果队列为空，那么在notEmpty对象上等待，
            //当put函数调用时，会调用notEmpty的notify进行通知。
            notEmpty.await();
        }
        return dequeue();
    } finally {
        lock.unlock();
    }
}
private E dequeue() {
    E x = (E) items[takeIndex];
    items[takeIndex] = null; //取出takeIndex位置的元素
    if (++takeIndex == items.length)
        //如果到了尾部，将指针重新调整到头部
        takeIndex = 0;
    count--;
    ....
    //通知notFull对象上等待的线程
    notFull.signal();
    return x;
}

2.LinkedBlockingQueue

(1) 要点概述

LinkedBlockingQueue 是一个用链表实现的有界阻塞队列。此队列按照先进先出的原则对元素进行排序,如果不指定容量，默认为Integer.MAX_VALUE，也就是无界队列。所以为了避免队列过大造成机器负载或者内存爆满的情况出现，我们在使用的时候建议手动传一个队列的大小。

(2)代码分析实现

1> 属性

/**
 * 节点类，用于存储数据
 */
static class Node<E> {
    E item;
    Node<E> next;

    Node(E x) { item = x; }
}

/** 阻塞队列的大小，默认为Integer.MAX_VALUE */
private final int capacity;

/** 当前阻塞队列中的元素个数 */
private final AtomicInteger count = new AtomicInteger();

/**
 * 阻塞队列的头结点
 */
transient Node<E> head;

/**
 * 阻塞队列的尾节点
 */
private transient Node<E> last;

/** 获取并移除元素时使用的锁，如take, poll, etc */
private final ReentrantLock takeLock = new ReentrantLock();

/** notEmpty条件对象，当队列没有数据时用于挂起执行删除的线程 */
private final Condition notEmpty = takeLock.newCondition();

/** 添加元素时使用的锁如 put, offer, etc */
private final ReentrantLock putLock = new ReentrantLock();

/** notFull条件对象，当队列数据已满时用于挂起执行添加的线程 */
private final Condition notFull = putLock.newCondition();

从上面的属性我们知道，每个添加到LinkedBlockingQueue队列中的数据都将被封装成Node节点，添加的链表队列中，其中head和last分别指向队列的头结点和尾结点。与ArrayBlockingQueue不同的是，LinkedBlockingQueue内部分别使用了takeLock 和 putLock 对并发进行控制，也就是说，添加和删除操作并不是互斥操作，可以同时进行，这样也就可以大大提高吞吐量。

这里如果不指定队列的容量大小，也就是使用默认的Integer.MAX_VALUE，如果存在添加速度大于删除速度时候，有可能会内存溢出，这点在使用前希望慎重考虑。另外，LinkedBlockingQueue对每一个lock锁都提供了一个Condition用来挂起和唤醒其他线程。

2> 构造函数

public LinkedBlockingQueue() {
    // 默认大小为Integer.MAX_VALUE
    this(Integer.MAX_VALUE);
}

public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node<E>(null);
}

public LinkedBlockingQueue(Collection<? extends E> c) {
    this(Integer.MAX_VALUE);
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        int n = 0;
        for (E e : c) {
            if (e == null)
                throw new NullPointerException();
            if (n == capacity)
                throw new IllegalStateException("Queue full");
            enqueue(new Node<E>(e));
            ++n;
        }
        count.set(n);
    } finally {
        putLock.unlock();
    }
}

默认的构造函数和最后一个构造函数创建的队列大小都为Integer.MAX_VALUE，只有第二个构造函数用户可以指定队列的大小。第二个构造函数最后初始化了last和head节点，让它们都指向了一个元素为null的节点。

最后一个构造函数使用了putLock来进行加锁，但是这里并不是为了多线程的竞争而加锁，只是为了放入的元素能立即对其他线程可见。

2> put方法

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    // 获取锁中断
    putLock.lockInterruptibly();
    try {
        //判断队列是否已满，如果已满阻塞等待
        while (count.get() == capacity) {
            notFull.await();
        }
        // 把node放入队列中
        enqueue(node);
        c = count.getAndIncrement();
        // 再次判断队列是否有可用空间，如果有唤醒下一个线程进行添加操作
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    // 如果队列中有一条数据，唤醒消费线程进行消费
    if (c == 0)
        signalNotEmpty();
}

private void enqueue(Node<E> node) {
    last = last.next = node;
}

put总共做了以下情况的考虑：

队列已满，阻塞等待。
队列未满，创建一个node节点放入队列中，如果放完以后队列还有剩余空间，继续唤醒下一个添加线程进行添加。如果放之前队列中没有元素，放完以后要唤醒消费线程进行消费。

enqueue用图形表示

3>take方法

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        // 队列为空，阻塞等待
        while (count.get() == 0) {
            notEmpty.await();
        }
        x = dequeue();
        c = count.getAndDecrement();
        // 队列中还有元素，唤醒下一个消费线程进行消费
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    // 移除元素之前队列是满的，唤醒生产线程进行添加元素
    if (c == capacity)
        signalNotFull();
    return x;
}

private E dequeue() {
    // 获取到head节点
    Node<E> h = head;
    // 获取到head节点指向的下一个节点
    Node<E> first = h.next;
    // head节点原来指向的节点的next指向自己，等待下次gc回收
    h.next = h; // help GC
    // head节点指向新的节点
    head = first;
    // 获取到新的head节点的item值
    E x = first.item;
    // 新head节点的item值设置为null
    first.item = null;
    return x;
}

take方法总共做了以下情况的考虑：

队列为空，阻塞等待。
队列不为空，从队首获取并移除一个元素，如果消费后还有元素在队列中，继续唤醒下一个消费线程进行元素移除。如果放之前队列是满元素的情况，移除完后要唤醒生产线程进行添加元素。

dequeue用图形表示

dequeue方法可看懂写法

private E dequeue() {
    // 获取到head节点
    Node<E> h = head;
    // 获取到head节点指向的下一个节点，也就是节点A
    Node<E> first = h.next;
    // 获取到下下个节点，也就是节点B
    Node<E> next = first.next;
    // head的next指向下下个节点，也就是图中的B节点
    h.next = next;
    // 得到节点A的值
    E x = first.item;
    first.item = null; // help GC
    first.next = first; // help GC
    return x;
}

3.ArrayBlockingQueue和LinkedBlockingQueue区别

LinkedBlockingQueue是一个阻塞队列，内部由两个ReentrantLock来实现出入队列的线程安全，由各自的Condition对象的await和signal来实现等待和唤醒功能。它和ArrayBlockingQueue的不同点在于：

队列大小有所不同，ArrayBlockingQueue是有界的初始化必须指定大小，而LinkedBlockingQueue可以是有界的也可以是无界的(Integer.MAX_VALUE)，对于后者而言，当添加速度大于移除速度时，在无界的情况下，可能会造成内存溢出等问题。
数据存储容器不同，ArrayBlockingQueue采用的是数组作为数据存储容器，而LinkedBlockingQueue采用的则是以Node节点作为连接对象的链表。
由于ArrayBlockingQueue采用的是数组的存储容器，因此在插入或删除元素时不会产生或销毁任何额外的对象实例，而LinkedBlockingQueue则会生成一个额外的Node对象。这可能在长时间内需要高效并发地处理大批量数据的时，对于GC可能存在较大影响。
两者的实现队列添加或移除的锁不一样，ArrayBlockingQueue实现的队列中的锁是没有分离的，即添加操作和移除操作采用的同一个ReenterLock锁，而LinkedBlockingQueue实现的队列中的锁是分离的，其添加采用的是putLock，移除采用的则是takeLock，这样能大大提高队列的吞吐量，也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

四. 实战场景应用

最近在做日志记录功能,具体实现是这样的: 通过返回通知AfterReturning对相应加了注解的方法进行拦截,然后对接收参数以及返回值进行封装(不同接口解析封装不同),最终插入到mysql数据库.

但是由于数据量加大,封装和插入耗时太多,于是在拦截之后对接收参数和返回值只做统一的简单封装,然后推到阻塞队列,然后另起一个线程从阻塞队列种取数据根据不同的接口对参数和返回值做解析封装,最终入mysql

1.阻塞队列代码

@Component
public class LogQueue extends LinkedBlockingQueue {

    public LogQueue(){
        //指定大小
        super(10000);
    }
}

2. 返回通知

@Slf4j
@Aspect
@Component
public class LogAspect {

    @Autowired
    LogQueue logQueue;

    @Pointcut("@annotation(com.xx.annotation.Log)")
    public void pointcut() {
    }

    /***
     * 不用环绕通知，环绕通知内部抛出异常会影响接口的正常执行，影响正常功能（要么就try...catch）
     * 将环绕改为AfterReturning,方法return之后执行
     * @param jp
     * @param result  返回结果
     * @return
     */
    @AfterReturning(value = "pointcut()", returning = "result")
    public void logAfterReturning(JoinPoint jp, Object result) {
        try {
            if (!dutyProperties.isOpenAopLog()) {
                //日志功能未开启
            }
            // 获取 request
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            StringBuffer requestURL = request.getRequestURL();
            String requestWay = request.getMethod();
            String methodName = jp.getSignature().getName();
            // 设置 IP 地址
            String ip = IPUtil.getIpAddr(request);
            String token = request.getHeader("XX_XX_XX");
            //用户信息
            LoginResponseBean loginResponseBean = TokenUserUtil.getUserByToken(token);
            //参数信息
            Map<String, Object> map = new HashMap<>();
            Object[] args = jp.getArgs();
            if (args != null) {
                for (Object arg : args) {
                    if (!(arg instanceof HttpServletRequest) && !(arg instanceof HttpServletResponse) && !(arg instanceof MultipartFile)) {
                        String argsClone = JSONObject.toJSONString(arg);
                        map.put("args", argsClone);
                        break;
                    }
                }
            }
            //返回结果
            if (result != null) {
                String resultClone = JSONObject.toJSONString(result);
                map.put("result", resultClone);
            }
            map.put("requestURL", requestURL.toString());
            map.put("ip", ip);
            //请求方式
            map.put("requestWay", requestWay);
            map.put("loginResponseBean", loginResponseBean);
            if (loginResponseBean!=null) {
                //非登陆接口
                map.put("userName", loginResponseBean.getUserName());
                map.put("token", token);
            }else{
                //登陆接口
                String username = JSONObject.parseObject((String) map.get("args")).getString("username");
                map.put("userName",username);
            }
            map.put("methodName", methodName);
            map.put("operateTime", DateUtil.getUTCTimeStr(new Date()));
            // 不直接入库，与多维一样，先推阻塞队列，在取出数据封装入库，以免因日志功能造成整个程序卡死
            //为防止响应,设置超时时间,100毫秒之内入不了队列就抛弃该操作,
            boolean offer = logQueue.offer(map, 100, TimeUnit.MILLISECONDS);
            if (!offer) {
                log.info("日志阻塞队列放入消息异常");
            }
            log.info("日志切面执行结束#####################阻塞队列数据长度" + logQueue.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

3. 读取阻塞队列数据的线程

@Component
@Slf4j
public class SaveLogProcess {
    @Autowired
    LogQueue logQueue;
    @Autowired
    SysLogMapper sysLogMapper;


    @PostConstruct
    public void init() {
        if (!dutyProperties.isOpenAopLog()) {
            //日志功能未开启,直接return
            return;
        }
        new Thread(() -> {
            Thread.currentThread().setName("SaveLogProcessThread");
            while (true) {
                try {
                    //从阻塞队列中取出存放好的数据
                    Map<String, Object> map = (Map<String, Object>) logQueue.take();
                    if (map == null) {
                        //队列为空暂时无数据
                        log.info("队列中暂无数据，线程正常");
                        Thread.sleep(5);
                    } else {
                        //封装数据
                        SysLog sysLog = dealWithData(map);
                        sysLogMapper.save(sysLog);
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }).start();

    }

weixin_42232931

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java数据结构----队列(二)之阻塞队列

参考文章:https://blog.csdn.net/tonywu1992/article/details/83419448一. 概述阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和阻塞移除方法1）支持阻塞的插入方法：意思是当队列满时，队列会阻塞住插入元素的线程，直到队列有空位。 2）支持阻塞的移除方法：意思是在队列为空时，获取元素...
复制链接

扫一扫

专栏目录