[資料結構與演算法]佇列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;
    }
}