Java中的队列

0

最近在看数据结构的时候,看到了队列这里,在实际的开发中我们很少会手动的去实现一个队列,甚至很少直接用到队列,但是在Java的包中有一些具有特殊属性的队列应用的比较广泛,例如:阻塞队列&并发队列.

阻塞队列

阻塞队列(BlockingQueue)是一个额外支持两种操作的队列。这两个附加的操作是:
1、在队列为空时,获取元素的线程会等待队列变为非空。
2、当队列满时,存储元素的线程会等待队列可用。
阻塞队列常用于生产者和消费者的场景,生产者是往队列里添加元素的线程,消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器,而消费者也只从容器里拿元素。


阻塞队列提供了四种处理方法:

  • 抛出异常

    add(e):在添加元素的时候如果队列已满,那么直接抛出异常。
    remove(e):移除元素,如果队列为空,那么抛出异常。
    element():检查方法。
    
    public static void test() {
       ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(10);
       for (int i=0; i<blockingQueue.size() + 1; i++) {
           blockingQueue.add("string"+i);
       }
    }
    结果:Exception in thread "main" java.lang.IllegalStateException: Queue full
    源码如下:
    public boolean add(E var1) {
       return super.add(var1);
    }
    public boolean add(E var1) {
       //调用offer方法
       if (this.offer(var1)) {
           return true;
       } else {
           throw new IllegalStateException("Queue full");
       }
    }
    
    /**offer(var1)在ArrayBlockingQueue中的实现源码如下:*/
    public boolean offer(E var1) {
       checkNotNull(var1);
       ReentrantLock var2 = this.lock;
       var2.lock();
    
       boolean var3;
       try {
           //如果队列已满,返回false
           if (this.count == this.items.length) {
               var3 = false;
               return var3;
           }
           //进行入队操作
           this.enqueue(var1);
           var3 = true;
       } finally {
           var2.unlock();
       }
       return var3;
    }
    
  • 返回特殊值

    1、offer(e) 入队的时候返回特殊值,在不同的阻塞队列中实现有一定的差别
    2、poll() 出队的时候返回特殊的值
    3、peek() 测试出队能否成功
    
  • 一直阻塞

    1、put(e) 如果队列已满,那么会一直阻塞,直到成功
    2、take()  如果队列为空,那么出队会一直阻塞,直到成功
    
  • 阻塞,超时退出

    1、offer(e,time,unit)
    2、poll(time,unit)
    
    

Java中的阻塞队列
JDK7提供了7个阻塞队列。分别是

  1. ArrayBlockingQueue :一个由数组结构组成的有界阻塞队列。
  2. LinkedBlockingQueue :一个由链表结构组成的有界阻塞队列。
  3. PriorityBlockingQueue :一个支持优先级排序的无界阻塞队列。
  4. DelayQueue:一个使用优先级队列实现的无界阻塞队列。
  5. SynchronousQueue:一个不存储元素的阻塞队列。
  6. LinkedTransferQueue:一个由链表结构组成的无界阻塞队列。
  7. LinkedBlockingDeque:一个由链表结构组成的双向阻塞队列。

下面具体看一下每一种阻塞队列的实现方式以及使用场景:

1. ArrayBlockingQueue

特性:用数组实现的实现的有界阻塞队列,默认情况下不保证线程公平的访问队列(按照阻塞的先后顺序访问队列),队列可用的时候,阻塞的线程都可以争夺队列的访问资格,当然也可以使用以下的构造方法创建一个公平的阻塞队列。
ArrayBlockingQueue<String> blockingQueue2 = new ArrayBlockingQueue<>(10, true);
下面通过源码探究以下,这个阻塞队列是如何实现的?如果实现公平与非公平的控制。
  • 构造过程
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();
}
/**阻塞队列的公平与非公平是通过可重入锁来实现的,关于为什么可重入锁可以实现线程访问的公平非公平特性,我们晚一点分析一下ReentrantLock的实现原理。

【关于ReentrantLock的实现原理】https://segmentfault.com/a/11...

  • add(E) 操作,如果add失败,那么抛出异常
public boolean add(E e) {
    return super.add(e);
}
/**AbstractQueue 父类的add方法*/
public boolean add(E e) {
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}
/**通过多态调用自己的offer(e)实现*/
public boolean offer(E e) {
    checkNotNull(e);
    //加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        //如果队列满了,那么返回false
        if (count == items.length)
            return false;
        else {
            //入队
            enqueue(e);
            return true;
        }
    } finally {
        lock.unlock();
    }
}
private void enqueue(E var1) {
    Object[] var2 = this.items;
    //putIndex可以认为是队列的队尾后的一个位置,数据入队对应的位置,如果队列满了,那么putIndex设置为0
    var2[this.putIndex] = var1;
    if (++this.putIndex == var2.length) {
        this.putIndex = 0;
    }

    ++this.count;
    //唤醒一个等待在condition上的线程
    this.notEmpty.signal();
}
  • put(E e) put操作,如果队列已满,那么会一直阻塞,直到put成功
public void put(E var1) throws InterruptedException {
    checkNotNull(var1);
    ReentrantLock var2 = this.lock;
    //加锁,可被线程中断返回
    var2.lockInterruptibly();
    try {
        //如果队列已经满了,那么阻塞
        while(this.count == this.items.length) {
            this.notFull.await();
        }
        //进行入队操作
        this.enqueue(var1);
    } finally {
        var2.unlock();
    }
}
/**
 * 在队列满的情况put操作被阻塞,那么什么时候该操作可以被唤醒呢?很显然是队列中出现空地的情况下,才会被唤醒在notFull这种条件下 
 * 阻塞的操作:
 * 所以在发生以下操作的时候,会被唤醒进行入队的操作
 * 1、dequeue()操作 2、removeAt(int var1)操作 3、clear() 4、drainTo
 */
  • take() 出队操作,如果队列为空,那么阻塞,直到队列中包含对应元素唤醒
/**实现比较容易,和上面的操作异曲同工*/
public E take() throws InterruptedException {
    ReentrantLock var1 = this.lock;
    var1.lockInterruptibly();

    Object var2;
    try {
        while(this.count == 0) {
            this.notEmpty.await();
        }

        var2 = this.dequeue();
    } finally {
        var1.unlock();
    }

    return var2;
}
个人总结:实现阻塞操作和核心在于线程挂起以及线程的唤醒,在Java中提供了两种线程等待以及线程唤醒的方式。一是基于对象监视器的wait(),notify()方法。 二是通过Condition.await()和signal()方法。

2. LinkedBlockingQueue

基于链表实现的有界阻塞队列。此队列的默认和最大长度为Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序。这个队列的实现原理和ArrayBlockingQueue实现基本相同。可以看一下队列的定义:
  • 队列的定义
/**默认的构造函数*/
public LinkedBlockingQueue() {
    this(2147483647);
}

public LinkedBlockingQueue(int var1) {
    this.count = new AtomicInteger();
    this.takeLock = new ReentrantLock();
    this.notEmpty = this.takeLock.newCondition();
    this.putLock = new ReentrantLock();
    this.notFull = this.putLock.newCondition();
    if (var1 <= 0) {
        throw new IllegalArgumentException();
    } else {
        this.capacity = var1;
        //链表的头结点和尾节点,默认是空
        this.last = this.head = new LinkedBlockingQueue.Node((Object)null);
    }
}

3、PriorityBlockingQueue

一个支持优先级的无界队列。默认情况下元素采取自然顺序排列,也可以通过比较器comparator来指定元素的排序规则。元素按照升序排列。具体是如何实现的?
  • 队列的定义以及构造方法
/**定义和通常的阻塞队列相同,AbstractQueue中定义了队列的基本操作,BlockingQueue中定义可阻塞队列的相关操作定义*/
public class PriorityBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>
/**构造方法,默认的无参构造方法,调用的是另一个构造方法,默认定义了一个队列的容量,那为什么说他是无界队列呢?接着向下*/
public PriorityBlockingQueue() {
    this(DEFAULT_INITIAL_CAPACITY, null);
}
/**所有的构造方法最后调用的构造方法, comparator是一个比较器,通过比较器可以确定队列中元素的排列顺序*/
public PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparator) {
    if (initialCapacity < 1)
        throw new IllegalArgumentException();
    this.lock = new ReentrantLock();
    this.notEmpty = lock.newCondition();
    this.comparator = comparator;
    /**队列是基于数组实现的*/
    this.queue = new Object[initialCapacity];
}
  • add 操作以及offer操作
public boolean add(E e) {
    return offer(e);
}
/**
 * offer操作
 */
public boolean offer(E e) {
    if (e == null)
        throw new NullPointerException();
    final ReentrantLock lock = this.lock;
    lock.lock();
    int n, cap;
    Object[] array;
    //如果队列已满,那么尝试进行扩容(个人感觉这里使用 >= 并不是很合理)
    while ((n = size) >= (cap = (array = queue).length))
        tryGrow(array, cap);
    try {
        Comparator<? super E> cmp = comparator;
        if (cmp == null)
            //使用默认的比较方法将e放到队列中
            siftUpComparable(n, e, array);
        else
            //使用指定的比较顺序将数据插入到队列中
            siftUpUsingComparator(n, e, array, cmp);
        size = n + 1;
        //激活一个在notEmpty这个condition上等待的线程
        notEmpty.signal();
    } finally {
        lock.unlock();
    }
    return true;
}
/**tryGrow()实现*/
private void tryGrow(Object[] array, int oldCap) {
    //这里先释放了锁,最后需要重新获取锁,那么这个时候所有的add操作都会执行下面的代码段
    lock.unlock(); // must release and then re-acquire main lock
    Object[] newArray = null;
    if (allocationSpinLock == 0 &&
        UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
                                 0, 1)) {
        try {
            int newCap = oldCap + ((oldCap < 64) ?
                                   (oldCap + 2) : // grow faster if small
                                   (oldCap >> 1));
            if (newCap - MAX_ARRAY_SIZE > 0) {    // possible overflow
                int minCap = oldCap + 1;
                if (minCap < 0 || minCap > MAX_ARRAY_SIZE)
                    throw new OutOfMemoryError();
                newCap = MAX_ARRAY_SIZE;
            }
            if (newCap > oldCap && queue == array)
                newArray = new Object[newCap];
        } finally {
            allocationSpinLock = 0;
        }
    }
    if (newArray == null) // back off if another thread is allocating
        Thread.yield();
    lock.lock();
    if (newArray != null && queue == array) {
        queue = newArray;
        System.arraycopy(array, 0, newArray, 0, oldCap);
    }
}

并发队列


如果觉得我的文章对你有用,请随意赞赏

你可能感兴趣的

载入中...