3.Java数据结构原理解析-Queue系列

最新推荐文章于 2024-07-08 00:12:54 发布
最新推荐文章于 2024-07-08 00:12:54 发布
阅读量2.5k 收藏 3
点赞数
分类专栏： 数据结构与算法 Java数据结构原理解析 文章标签： queue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011983531/article/details/78651466
版权

Queue，也就是队列，满足FIFO的特性。
在Java中，Queue是一个接口，它的实现类有很多，其中非线程安全的代表是LinkedList，线程安全的有阻塞和非阻塞的，阻塞的大都实现了Queue的子接口BlockingQueue(阻塞队列)，例如：ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、DelayQueue等。非阻塞的有ConcurrentLinkedQueue。

Queue接口方法定义：

//添加元素，成功返回true，容量不够抛IllegalStateException
boolean add(E e)
//添加元素，成功返回true，容量不足返回false
boolean offer(E e)

//移除队首元素，队列为空时抛NoSuchElementException
E remove()
//移除队首元素，队列为空时返回null
E poll()

//查看队首元素，队列为空时抛NoSuchElementException
E element()
//查看队首元素，队列为空时返回null
E peek()

BlockingQueue接口定义（BlockingQueue除了继承Queue定义的方法外，还加入了自己的阻塞方法）：

//添加元素，容量不足阻塞
void put(E e) throws InterruptedException
//添加元素，容量不足时等待指定时间
boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException

//移除队首元素，队列为空时阻塞
E take() throws InterruptedException
//移除队首元素，队列为空时等待指定时间
E poll(long timeout, TimeUnit unit) throws InterruptedException

队列大多数是在多线程环境下使用的，生产者线程往队列中添加元素，消费者线程从队列中取出元素。所以，下面重点讨论ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue是采用什么样的数据结构和算法来保证队列的线程安全性的。

1.阻塞队列 ArrayBlockingQueue

ArrayBlockingQueue底层的数据结构是数组和循环队列，使用一个可重入锁和这个锁的两个条件对象进行并发控制。
首先，来看看ArrayBlockingQueue的属性。

//存放元素的数组
final Object[] items;
//循环队列头指针，起始值为0
int takeIndex;
//循环队列尾指针,指向下一个元素插入的位置，起始值为0
int putIndex;
//元素的个数
int count;

//可重入锁(被final修饰，之所以没有初始化，是因为所有的构造方法里面都对lock进行了初始化)
final ReentrantLock lock;
//队列非空条件
private final Condition notEmpty;
//队列未满条件
private final Condition notFull;

ArrayBlockingQueue的长度是固定的，无法扩容，所以创建一个ArrayBlockingQueue对象时，必须指定队列的容量，并且ArrayBlockingQueue不允许原始为null。从构造函数上可以看出这一点。

//创建一个指定容量的队列，锁默认是非公平的
public ArrayBlockingQueue(int capacity) {
    this(capacity, false);
}
//创建一个指定容量、指定锁的公平性的队列
public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0)
        throw new IllegalArgumentException();
    this.items = new Object[capacity];
    //创建锁
    lock = new ReentrantLock(fair);
    notEmpty = lock.newCondition();
    notFull =  lock.newCondition();
}

//用现有的集合创建一个指定容量、指定锁的公平性的队列
public ArrayBlockingQueue(int capacity, boolean fair,
                          Collection<? extends E> c) {
    //创建队列
    this(capacity, fair);

    final ReentrantLock lock = this.lock;
    lock.lock(); // Lock only for visibility, not mutual exclusion(锁定只用于可见性，而不是互斥)
    try {
        int i = 0;
        try {
            for (E e : c) {
                checkNotNull(e);
                items[i++] = e;
            }
        } catch (ArrayIndexOutOfBoundsException ex) {
            throw new IllegalArgumentException();
        }
        count = i;
        //尾指针
        putIndex = (i == capacity) ? 0 : i;
    } finally {
        lock.unlock();
    }
}

（1）插入元素add、offer、put

public boolean add(E e) {
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}
public boolean offer(E e) {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        if (count == items.length)
            return false;
        else {
            insert(e);
            return true;
        }
    } finally {
        lock.unlock();
    }
}

private void insert(E x) {
    items[putIndex] = x;
    //队列尾指针+1
    putIndex = inc(putIndex);
    ++count;
    //通知在notEmpty上等待的线程
    notEmpty.signal();
}

//循环加。循环队列的实现就体现在这里
final int inc(int i) {
    return (++i == items.length) ? 0 : i;
}

public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    //在锁上等待，直到获取锁，但是会响应中断，优先考虑响应中断，而不是响应锁的普通获取或重入获取。
    //不明白为什么add和offer方法使用lock，而put方法使用lockInterruptibly?
    lock.lockInterruptibly();
    try {
        //队列已满，在notFull对象上等待
        while (count == items.length)
            notFull.await();
        insert(e);
    } finally {
        lock.unlock();
    }
}

（2）取出元素remove、poll、take

public E remove() {
    E x = poll();
    if (x != null)
        return x;
    else
        throw new NoSuchElementException();
}

public E poll() {
   final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        //队列为空时返回null
        return (count == 0) ? null : extract();
    } finally {
        lock.unlock();
    }
}

private E extract() {
    final Object[] items = this.items;
    E x = this.<E>cast(items[takeIndex]);
    items[takeIndex] = null;
    //队列头指针+1
    takeIndex = inc(takeIndex);
    --count;
    //通知在notFull对象上等待的线程
    notFull.signal();
    return x;
}

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        //队列为空时，在notEmpty上等待
        while (count == 0)
            notEmpty.await();
        return extract();
    } finally {
        lock.unlock();
    }
}

2.阻塞队列 LinkedBlockingQueueue

LinkedBlockingQueueue底层的数据结构是单向链表，使用两个可重入锁（放锁和拿锁）和对象的条件对象来进行并发控制。
LinkedBlockingQueueue由于使用了两个锁，所以允许同时添加和取出元素。这一点是和ArrayBlockingQueue最大的区别。

一个类的属性体现了这个类的数据结构，我们首先看看LinkedBlockingQueueue的属性

//链表的节点。从节点可以看出该链表只有一个next指针，是单向的，
static class Node<E> {
    E item;

    Node<E> next;

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

//队列的容量，定义为final，说明所有的构造方法必须初始化容量
private final int capacity;

//元素的个数，因为使用了放锁和拿锁两个锁，所以同时添加和取出元素时存在并发问题，使用原子操作来保证元素的个数的准确性
private final AtomicInteger count = new AtomicInteger(0);

//单向链表头指针，head.item永远为null。(定义为transient说明不能序列化）
private transient Node<E> head;

//单向链表尾指针，last.next永远为null。(定义为transient说明不能序列化）
private transient Node<E> last;

//拿锁（控制remove、poll、take方法等）
private final ReentrantLock takeLock = new ReentrantLock();
private final Condition notEmpty = takeLock.newCondition();

//放锁（控制add、offer、put方法等）
private final ReentrantLock putLock = new ReentrantLock();
private final Condition notFull = putLock.newCondition();

照常理来说，取出一个元素后，队列应该是notFull，那么拿锁控制的是应该是notFull的条件变量，但是因为此处存在两把锁，可能在取出元素后，又有元素加入了。所有此处拿锁控制的是notEmpty，取出元素后，只要判断剩下的元素是否大于1就可以了，因为不可能有两个线程同时执行取操作。

（1）插入元素add、offer、put

//add方法是在AbstractQueue实现了，所以跟ArrayBlockingQueue一样
public boolean add(E e) {
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}

public boolean offer(E e) {
    if (e == null) throw new NullPointerException();
    final AtomicInteger count = this.count;
    if (count.get() == capacity)
        return false;
    int c = -1;
    Node<E> node = new Node(e);
    //锁定放锁
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        //队列未满
        if (count.get() < capacity) {
            enqueue(node);
            //队列长度+1
            c = count.getAndIncrement();
            //插入之后，队列还是未满，通知在notFull对象上的等待的线程（例如：put方法）
            if (c + 1 < capacity)
                notFull.signal();
        }
    } finally {
        putLock.unlock();
    }
    //c==0表示插入之前队列为空，队列为空说明可能有读线程在阻塞，如果c>0，说明肯定没有读线程在阻塞
    if (c == 0)
        signalNotEmpty();
    return c >= 0;
}

//signalNotEmpty虽然用在offder/put中，但是从不在putLock的同步区内。这样就保证同一时刻只持有一个锁，这样就不会出现死锁问题。
//？？？关于此处为什么加锁的问题，暂时就是这样理解的
private void signalNotEmpty() {
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
}

//入队。入队操作很简单，就是将链表尾指针的next节点指向当前节点，并把当前节点设置为尾指针
private void enqueue(Node<E> node) {
    last = last.next = node;
}

（2）取出操作remove、poll、take

//remove()方法是在AbstractQueue中实现了，跟ArrayBlockingQueue一样
public E remove() {
    E x = poll();
    if (x != null)
        return x;
    else
        throw new NoSuchElementException();
}

public E poll() {
    final AtomicInteger count = this.count;
    if (count.get() == 0)
        return null;
    E x = null;
    int c = -1;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        if (count.get() > 0) {
            //出队
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
        }
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();
    return x;
}

//出队操作比较简单，就是将单链表的头指针指向下一个元素
private E dequeue() {
    Node<E> h = head;
    Node<E> first = h.next;
    //不是很明白这个，如果要帮助GC，直接将h.next=null不是更好吗？
    h.next = h; // help GC
    head = first;
    E x = first.item;
    first.item = null;
    return x;
}

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条件上等待
            notEmpty.await();
        }
        x = dequeue();
        c = count.getAndDecrement();
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();
    return x;
}

private void signalNotFull() {
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        notFull.signal();
    } finally {
        putLock.unlock();
    }
}

3.阻塞队列 SynchronousQueue

　　SynchronousQueue跟上面两个阻塞队列不同，它内部没有容器，一个生产线程put的时候，如果当前没有消费线程执行take，此生产线程必须阻塞，等待一个消费线程调用take操作，take操作将会唤醒该生产线程，同时消费线程会获取生产线程的数据（即数据传递），这样的一个过程称为一次配对过程(当然也可以先take后put,原理是一样的)。

可以参考：https://zhuanlan.zhihu.com/p/29227508
https://www.jianshu.com/p/376d368cb44f?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io

4.非阻塞队列 ConcurrentLinkedQueue

ArrayBlockingQueue和LinkedBlockingQueue都是阻塞的，阻塞体现在入队和出队的时候需要加锁。
下面介绍的ConcurrentLinkedQueue是非阻塞的，ConcurrentLinkedQueue底层的数据结构和LinkedBlockingQueue相同，也是使用单链表，不同的是ConcurrentLinkedQueue通过sun.misc.Unsafe类的CAS操作来保证线程安全的。

Unsafe类提供了硬件级别的原子操作，主要compareAndSwapXXX方法实现。
关于Unsafe，网上有很多资源，请自行查阅。

我们首先来看看ConcurrentLinkedQueue的成员变量。

//单链表头节点
private transient volatile Node<E> head;

//单链表尾节点
private transient volatile Node<E> tail;

//节点类型。与LinkedBlockingQueue不同的是，所有的赋值操作都是通过Unsafe对象的CAS来完成的，所以是线程安全的
private static class Node<E> {
    volatile E item;
    volatile Node<E> next;

    Node(E item) {
        UNSAFE.putObject(this, itemOffset, item);
    }

    //为item赋值
    boolean casItem(E cmp, E val) {
        return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
    }

    void lazySetNext(Node<E> val) {
        UNSAFE.putOrderedObject(this, nextOffset, val);
    }

    //为next指针赋值
    boolean casNext(Node<E> cmp, Node<E> val) {
        return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
    }

    private static final sun.misc.Unsafe UNSAFE;
    private static final long itemOffset;
    private static final long nextOffset;

    static {
        try {
            //获取item属性和next属性的内存地址
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class k = Node.class;
            itemOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("item"));
            nextOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("next"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

（1）入队add、offer
这里写图片描述
需要注意的是，每次入队之后，tail并不是总指向最后一个节点。奇数时是倒数第二个节点，偶数时是第一个节点。

public boolean add(E e) {
    return offer(e);
}

public boolean offer(E e) {
    checkNotNull(e);
    final Node<E> newNode = new Node<E>(e);

    for (Node<E> t = tail, p = t;;) {
        //获得p的下一个节点
        Node<E> q = p.next;
        //如果下一个节点是null,也就是p节点就是尾节点
        if (q == null) {
            //将单链表的尾节点的next指针指向新节点
            if (p.casNext(null, newNode)) {
                if (p != t)
                     //如果tail不是尾节点则将入队节点设置为tail。
                     // 如果失败了，那么说明有其他线程已经把tail移动过
                    casTail(t, newNode);
                return true;
            }
            // Lost CAS race to another thread; re-read next
        }
        // 如果p节点等于p的next节点，则说明p节点和q节点都为空，表示队列刚初始化，所以返回
        else if (p == q)
            // We have fallen off list.  If tail is unchanged, it
            // will also be off-list, in which case we need to
            // jump to head, from which all live nodes are always
            // reachable.  Else the new tail is a better bet.
            p = (t != (t = tail)) ? t : head;
        else
            // Check for tail updates after two hops.
            p = (p != t && t != (t = tail)) ? t : q;
    }
}

//为队列的尾节点赋值
private boolean casTail(Node<E> cmp, Node<E> val) {
    return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
}

可参考：http://blog.csdn.net/u013991521/article/details/53068549

爱上香锅的麻辣
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3.java8 队列queue基础知识
Tang_zhihong的博客
03-19 1766
集合：Queue Queue：Deque,PriorityQueue,PriorityBlockingQueue，ArrayBlockingQueue Queue用于模拟队列这种数据结构。队列通常是指“先进先出（FIFO）”的容器。队列的头部保存在队列中存放时间最长的元素，尾部保存存放时间最短的元素。新元素插入到队列的尾部，取出元素会返回队列头部的元素。通常，队列不允许随机访问队列中的元素。 ...
java队列——queue详细分析
weixin_30443895的博客
11-22 6676
Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接 口。 Queue的实现 1、没有实现的阻塞接口的LinkedList： 实现了java.util.Queue接口和java.util.AbstractQueue接口　　内置的不阻塞队列： Pri...
Java零基础-集合：Queue
最新发布
喵手的博客
07-08 737
在Java中，Queue接口代表一种基于先进先出（FIFO）原则的集合。对于Java初学者来说，理解队列的概念及其在编程中的应用是十分重要的。本文将介绍Java中的Queue接口及其实现类，包括源代码解析、应用场景案例、优缺点分析、方法介绍和测试用例，旨在帮助Java零基础的学习者快速掌握队列的使用。Java的Queue接口定义了队列的基本操作，如入队（添加元素到队列末端）和出队（移除并获取队列前端的元素）。Queue接口是Collection接口的一个扩展。以下是Queueadd(E e)
队列（queue）原理
热门推荐
sun
11-17 4万+
像栈一样，队列（queue）也是一种线性表，它的特性是先进先出，插入在一端，删除在另一端。就像排队一样，刚来的人入队（push）要排在队尾(rear)，每次出队(pop)的都是队首(front)的人。如图1，描述了一个队列模型。 队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点： 队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FI
数据结构—队列(Queue)的原理以及Java实现案例
终生学习践行者
04-22 3331
详细介绍了队列的基本概念，并且使用Java语言分别实现了基于顺序结构和链式结构的队列。
Queue详解（Java）
喻师傅的学习笔记
01-17 990
Queue详解
java数据结构.rar
04-27
本资源"java数据结构.rar"包含了一系列关于Java数据结构的视频教程，涵盖了从基础到高级的主题，对于学习和提升Java编程能力非常有帮助。 首先，我们从"1-第一讲数组.avi"开始。数组是最基础的数据结构，它是一组...
Java算法题，数据结构分析和实现.zip
06-17
这个压缩包中的ljg_resource1可能是实际的代码示例、题目解析或者是数据结构实现的详细文档，通过学习这些内容，你可以深入理解各种数据结构的运作机制，并能运用到实际的Java项目中，提高编程效率和问题解决能力。
Chronicle-Queue.zip
08-19
《深入解析Java Chronicle Queue》 Java Chronicle Queue是一个高性能、低延迟、持久化的消息队列，专为复杂的实时系统设计。它的出现解决了在高频率交易、日志记录、事件驱动架构等场景下的数据处理问题。本篇文章...
2.Java集合与数据结构.rar
01-12
通过学习这些文档，开发者可以深入理解Java集合框架的内部工作原理，提升编程能力，有效利用各种数据结构解决实际问题，提高代码质量和执行效率。对于Java程序员来说，熟练掌握这些知识是必备的。
数据结构与算法答案——java语言描述
02-08
数据结构与算法是计算机科学的基础，对于理解和优化程序性能至关重要。...这些文件（如ch01到ch11的PDF）可能涵盖了上述知识点的详细解释和实例，通过学习，开发者可以增强对Java数据结构和算法的理解，提升编程能力。
Java 数据结构之队列(Queue)详解
chuyouyinghe的专栏
06-05 1527
通过enqueue()方法将元素入队，dequeue()方法将元素出队，peek()方法返回队列头部元素，size()方法返回队列当前元素个数，isEmpty()方法和isFull()方法检查队列是否为空或已满。但需要注意的是，由于数组的容量是固定的，当队列已满时，无法再添加新的元素，除非进行元素的出队操作。Queue接口是Java集合框架中定义的一个接口，它代表了一个先进先出（FIFO）的队列。它是Queue接口的扩展，可以方便地实现队列、栈和双向队列的功能，并提供了丰富的方法来操作和访问队列中的元素。
java Queue常用方法
发呆中!
09-29 2万+
对于Queue来说，就是一个FIFO（先进先出）的队列，添加元素只能在队尾，移除只能在队首。 对于这一组方法，成功返回true，在操作失败时抛出异常，这是与下面一组方法的主要区别。 add(E e)：添加一个元素到队尾 remove()：获取队首的元素，并从队列中移除 element()：获取队首的元素，但不从队列中移除   这一组，成功返回true，失败时返回一个特殊值(取决于操作，...
Java-Queue
weixin_42152849的博客
06-28 159
1.队列Queue Queue：只能在一端（队尾）进行插入，另一端（队头）进行输出，先进先出。 Java中Queue是java.util包中提供的接口，并扩展了java.util.Collection接口。 java.util public interface Queue<E> extends Collection<E> 2.Queue中常用方法 2.1 boolean add(E e)： 如果可以在不违反容量限制的情况下立即执行此操作，则将指定的元素插入此队列，成功时返回tru
Java学习笔记——容器之Queue
bingzhixi的博客
12-03 1027
Queue是一种很常见的数据结构类型，在Java里面Queue是一个接口，它只是定义了一个基本的Queue应该有哪些功能规约。实际上有多个Queue的实现，有的是采用线性表实现，有的基于链表实现。还有的适用于多线程的环境。java中具有Queue功能的类主要有如下几个：AbstractQueue, ArrayBlockingQueue, ConcurrentLinkedQueue, Linke
java中Queue
c1052981766的专栏
02-14 613
在并发队列中JDK提供了两种队列：ConcurrentLinkedQueue:支持高性能的QueueBlockingQueue:带阻塞的QueueConcurrentLinkedQueue是一种适用于高并发场景下的队列，通过无锁的方式，实现高并发状态下的高性能，通常性能优于BlockingQueue.是一种基于连接节点的无界线程安全队列。遵循FIFO原则，不允许NULL.注意：size 方法不是 ...
java数据结构之Queue
nongfuyumin的专栏
03-14 154
java数据结构之Queue java的数据结构比较多，一个个说也没那么多时间，所以挑一些上层接口来集中说下，今天说说Queue这个接口。 Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deq...
java中的Queue
zhangrilong的博客
11-09 1255
Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Q
【java】Queue
lzm18064126848的专栏
12-24 722
参考文章： http://www.cnblogs.com/qqzy168/p/3913994.html 与c++的queue不一样，java中queue只是一个接口，具体方法需要实现类去完成 package study; import java.util.LinkedList; import java.util.Queue; public class TestQueu
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值