[数据结构与算法]队列Queue 的多种实现

package queue;

/**
 * 队列接口
 * @author jzj
 *
 * @param <E>
 */
public interface Queue<E> {
    //入队
    public void enqueue(E e);

    //出队
    public E dequeue();

    //取队列第一个
    public E front();

    //队列是否为空
    public boolean isEmpty();

    //队列大小
    public int size();
}

package queue;

/**
 * 循环队列，使用数组实现
 * @author jzj
 */
public class ArrayQueue<E> implements Queue<E> {

    private Object lock = new Object();

    // 队列大小
    private int size = 1000;

    // 队列
    private E[] arrStr = (E[]) new Object[size];

    // 队列指针
    private int head = 0;

    // 队列尾指针
    private int tail = 0;

    /**
     * 入队
     * @param o
     */
    public void enqueue(E o) {
        synchronized (lock) {

            // 如果队列已满
            while ((tail + 1) % size == head) {
                try {
                    System.out.println("队列已满，" + Thread.currentThread().getName()
                            + " 线程阻塞...");
                    // 队列满时线程阻塞
                    lock.wait();//注，这里一定要放在while条件里，因为获取锁后，条件不一定还成立
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 如果队列未满
            arrStr[tail] = o;
            // 指针下移
            tail = (tail + 1) % size;
            // 入队后通知消费线程
            lock.notifyAll();
        }
    }

    /**
     * 出队
     * @return
     */
    public E dequeue() {
        synchronized (lock) {
            // 如果队列为空
            while (head == tail) {
                try {
                    System.out.println("队列为空，" + Thread.currentThread().getName()
                            + " 线程阻塞...");
                    // 队列空时线程阻塞
                    lock.wait();//注，这里一定要放在while条件里，因为获取锁后，条件不一定还成立
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 队列非空
            E tempStr = arrStr[head];

            arrStr[head] = null;//注，这里出队后释放对象，加快回收，不然大的对象可能造内存泄露
            head = (head + 1) % size;

            // 出队后通知生产者
            lock.notifyAll();
            return tempStr;

        }
    }

    //取队列第一个
    public E front() {
        synchronized (lock) {
            // 如果队列为空
            while (head == tail) {
                try {
                    System.out.println("队列为空，" + Thread.currentThread().getName()
                            + " 线程阻塞...");
                    // 队列空时线程阻塞
                    lock.wait();//注，这里一定要放在while条件里，因为获取锁后，条件不一定还成立
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 队列非空
            return arrStr[head];
        }
    }

    //队列是否为空
    public boolean isEmpty() {
        return head == tail;
    }

    //队列大小
    public int size() {

        return Math.abs(tail - head);
    }
}

Jdk1.5已有java.util.Queue接口

使用1.5中并发新特性实现循环队列：来源于 API java.util.concurrent.locks.Condition

//循环缓冲队列，从队首放，从队尾出。牺牲数组的最后一个元素，用来判断队列是否满
class BoundedBuffer {
    final Lock lock = new ReentrantLock();//可重入锁
    final Condition notFull = lock.newCondition();//缓冲空条件对象
    final Condition notEmpty = lock.newCondition();//缓冲非空条件对象

    final Object[] items = new Object[100];//缓冲区
    int putptr/*队首*/, takeptr/*队尾*/, count/*可用个数*/;

    //将元素放入缓冲，供生产线程调用
    public void put(Object x) throws InterruptedException {
        lock.lock();//获取锁
        try {
            //注，要将await置于循环中，这也wait道理一样
            while (count == items.length)
                notFull.await();//缓冲满时等待，且释放锁
            items[putptr] = x;
            //如果队首指针指向数组最后索引时，重新指向数组第一个元素位置
            if (++putptr == items.length)
                putptr = 0;
            ++count;//循环队列中存入的元素个数
            notEmpty.signal();//放入元素后通知其它消费线程可以消费了
        } finally {
            lock.unlock();//释放锁
        }
    }

    //从缓冲取出元素，供消费线程调用
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await();//如果缓冲空则等待
            Object x = items[takeptr];
            //如果队尾指针指向数组最后索引时，重新指向数组第一个元素位置
            if (++takeptr == items.length)
                takeptr = 0;
            --count;
            notFull.signal();//取出后会有空间，通知生产线程
            return x;
        } finally {
            lock.unlock();
        }
    }
}

package queue;

import java.util.LinkedList;

/**
 * 使用 LinkedList 实现队列
 * @author jzj
 *
 * @param <E>
 */
public class LinkedListQueue<E> implements Queue<E> {
    private LinkedList<E> linkedList = new LinkedList<E>();

    //入队
    public void enqueue(E e) {
        linkedList.addLast(e);
    }

    //出队
    public E dequeue() {
        return linkedList.removeFirst();
    }

    //取队列第一个
    public E front() {
        return linkedList.getFirst();
    }

    //队列是否为空
    public boolean isEmpty() {
        return linkedList.isEmpty();
    }

    //队列大小
    public int size() {
        return linkedList.size();
    }
}

package queue;

import java.util.NoSuchElementException;

/**
 * 使用 循环双向链 实现队列
 * 
 * @author jzj
 *
 * @param <E>
 */
public class LinkedQueue<E> implements Queue<E> {
    private class Entry {
        E element;//数据域
        Entry next;//后驱节点
        Entry previous;//前驱节点

        /**
         * @param element 数据域
         * @param next 后驱节点
         * @param previous 前驱节点
         */
        Entry(E element, Entry next, Entry previous) {
            this.element = element;
            this.next = next;
            this.previous = previous;
        }
    }

    /*
     * 头节点，永远代表头。链中无结节时节点中的前后驱指针域指向自己，当有元素时
     * 头节点的前驱指针域previous指向链中最后一个节点，而next指针域指向链中的
     * 第一个节点
     */
    private Entry header = new Entry(null, null, null);

    private int size = 0;//链表中节点个数，但不包括头节点header

    public LinkedQueue() {
        //初始化时头的前后驱指针都指向自己
        header.next = header.previous = header;
    }

    //入队，在链表中的最后位置加入元素，相当于 LinkedList 的add、addBefore、addLast方法实现
    public void enqueue(E e) {
        //在双向链后面加入元素
        Entry newEntry = new Entry(e, header, header.previous);
        //让新元素的前驱节点（新增前链的最后点）的前驱指向新加元素
        newEntry.previous.next = newEntry;
        //让新元素的后驱节点（header头节点）的前驱指向新加元素
        newEntry.next.previous = newEntry;
        size++;
    }

    //出队，从链表中的第一个元素开始出队，相当于 LinkedList 的removeFirst方法实现
    public E dequeue() {
        //要出队（删除）的节点的数据域
        E first = header.next.element;
        Entry e = header.next;
        //要删除的节点为头节点时不能删除
        if (e == header) {
            throw new NoSuchElementException();
        }

        //将删除节点的前驱节点的next域指针指向删除节点的后驱节点
        e.previous.next = e.next;
        //将删除节点的后驱节点的previous域指针指向删除节点的前驱节点
        e.next.previous = e.previous;
        size--;
        return first;
    }

    //取队列的第一个元素，相当于 LinkedList 的getFirst方法实现
    public E front() {
        if (size == 0)
            throw new NoSuchElementException();

        return header.next.element;
    }

    //队列是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    //队列大小
    public int size() {
        return size;
    }
}