Java程序 实现LinkedBlockingQueue API

LinkedBlockingQueue API是一个基于链接节点的可选边界的队列。它以FIFO（先进先出）的顺序排列元素。这个队列的头部是在队列中存在时间最长的元素，队列的尾部是在队列中存在时间最短的元素。新的元素在队列的尾部插入，而队列的检索操作则在队列的头部获得元素。它属于java.util.concurrent包。它扩展了Object、AbstractCollection和AbstractQueue类。

容量参数的作用是防止队列过度扩张。容量（如果没有指定）等于Integer.MAX_VALUE。链接节点在每次插入时被动态创建，除非这将使队列超过容量。

LinkedBlockingQueue API是Java Collection Framework的一个成员。

所有实现的接口。

1. Serializable
2. Iterable<E>
3. Collection<E>
4. BlockingQueue<E>
5. Queue<E>

参数: E – 集合中元素的类型

语法:

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, Serializable

构造函数:

1. public LinkedBlockingQueue() – 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue。
   2. public LinkedBlockingQueue(Collection<? extends E> c) – 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue，最初包含指定Collection的元素。
   3. public LinkedBlockingQueue(int capacity) – 创建一个具有给定容量的LinkedBlockingQueue。

实现:

示例

// Java Program to Implement LinkedBlockingQueue API
 
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
 
public class BlockingQueue<E> {
    private LinkedBlockingQueue<E> q;
 
    // Creates a LinkedBlockingQueue with a size of
    // Integer.MAX_VALUE.
    public BlockingQueue()
    {
        q = new LinkedBlockingQueue<E>();
    }
 
    // Creates a LinkedBlockingQueue initially containing
    // the elements of the given collection
    public BlockingQueue(Collection<? extends E> c)
    {
        q = new LinkedBlockingQueue<E>(c);
    }
 
    // Creates a LinkedBlockingQueue with the given size
    public BlockingQueue(int size)
    {
        q = new LinkedBlockingQueue<E>(size);
    }
 
    // Returns true if the queue contains the given element
    public boolean contains(Object o)
    {
        return q.contains(o);
    }
 
    // Removes all elements from the queue and adds them to
    // the given collection.
    public int drainTo(Collection<? super E> c)
    {
        return q.drainTo(c);
    }
 
    //  Removes the elements from the queue and adds them to
    //  the given collection.
    public int drainTo(Collection<? super E> c, int maxEle)
    {
        return q.drainTo(c, maxEle);
    }
 
    // Returns an iterator over the elements in the queue
    public Iterator<E> iterator() { return q.iterator(); }
 
    // removes all the elements from the queue.
    void clear() { q.clear(); }
 
    // Inserts the given element at the end of the queue,
    // returning true upon inserting and false if the queue
    // is full.
    public boolean offer(E e) { return q.offer(e); }
 
    // inserts then given element at the end and wait for
    // the given time for the space to become available
    public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException
    {
        return q.offer(e, timeout, unit);
    }
 
    // Retrieves, but does not remove, the head of the
    // queue, or returns null if this queue is empty.
    public E peek() { return q.peek(); }
 
    //  Retrieves and removes the head of the queue
    public E poll() { return q.poll(); }
 
    // Retrieves and removes the head of the queue and wait
    // for the specified time for the element to become
    // available.
    public E poll(long tout, TimeUnit un)
        throws InterruptedException
    {
        return q.poll(tout, un);
    }
 
    // Returns the number of additional elements that the
    // queue can contain without blocking.
    public int remainingCapacity()
    {
        return q.remainingCapacity();
    }
 
    // Removes the specified element from the queue
    public boolean remove(Object o) { return q.remove(o); }
 
    // Returns the number of elements in the queue
    public int size() { return q.size(); }
 
    // Inserts the given element at the end of the queue,
    // wait for space to become available
    public void put(E e) throws InterruptedException
    {
        q.put(e);
    }
 
    // Retrieves and removes the head of the queue wait till
    // an element becomes available
    public E take() throws InterruptedException
    {
        return q.take();
    }
 
    // Returns an array containing all the elements in the
    // queue.
    public Object[] toArray() { return q.toArray(); }
 
    // Returns an array containing all of the elements in
    // the queue
    public <T> T[] toArray(T[] a) { return q.toArray(a); }
 
    // Returns a string representation of th collection.
    public String toString() { return q.toString(); }
 
    public static void main(String[] args)
    {
        BlockingQueue<Integer> q
            = new BlockingQueue<Integer>();
        try {
            q.put(1);
            q.put(2);
            q.put(3);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        System.out.println(
            "The elements of the LinkedBlockingQueue is ");
 
        Iterator<Integer> i = q.iterator();
 
        while (i.hasNext()) {
            System.out.print(i.next() + "\t");
        }
        System.out.println();
 
        System.out.println("The remaining capacity is "
                           + q.remainingCapacity());
 
        System.out.println("3 removed " + q.remove(3));
 
        q.offer(6);
        q.offer(7);
 
        System.out.println(
            "The peak element of the LinkedBlockingQueue is "
            + q.peek());
 
        System.out.println(
            "The peak element of the LinkedBlockingQueue is "
            + q.poll());
 
        System.out.println(
            "The LinkedBlockingQueue contains 4 :"
            + q.contains(4));
 
        System.out.println(
            "The LinkedBlockingQueue contains 1 :"
            + q.contains(1));
 
        System.out.println(
            "The size of the LinkedBlockingQueue is "
            + q.size());
 
        System.out.println(q);
    }
}

输出

The elements of the LinkedBlockingQueue is 
1    2    3    
The remaining capacity is 2147483644
3 removed true
The peak element of the LinkedBlockingQueue is 1
The peak element of the LinkedBlockingQueue is 1
The LinkedBlockingQueue contains 4 :false
The LinkedBlockingQueue contains 1 :false
The size of the LinkedBlockingQueue is 3
[2, 6, 7]

方法: