Java數據結構之隊列的實現以及隊列的應用之----簡單生產者消費者應用

Java數據結構之---Queue隊列

　　隊列（簡稱作隊，Queue）也是一種特殊的線性表，隊列的數據元素以及數據元素間的邏輯關系和線性表完全相同，其差別是線性表允許在任意位置插入和刪除，而隊列只允許在其一端進行插入操作在其另一端進行刪除操作。

      隊列中允許進行插入操作的一端稱為隊尾，允許進行刪除操作的一端稱為隊頭。隊列的插入操作通常稱作入隊列，隊列的刪除操作通常稱作出隊列。最簡單的例子就是我們平時的排隊，先進先出。

順序隊列的存儲結構

下圖是一個有6個存儲空間的順序隊列的動態示意圖，圖中front指示隊頭，rear指示隊尾。

~順序隊列的假溢出現象

      假溢出是由於隊尾rear的值和隊頭front的值不能由所定義數組下界值自動轉為數組上界值而產生的。因此，解決的方法是把順序隊列所使用的存儲空間構造成一個邏輯上首尾相連的循環隊列( Circular Queue)。

~解決方法

      當rear和front達到maxSize-1后，再加1就自動到0。這樣，就不會出現順序隊列數組的頭部已空出許多存儲空間，但隊尾卻因數組下標越界而引起溢出的假溢出問題。這里在代碼里面會詳細解釋~

在操作完成后，該隊列中會有兩個空格沒有數據元素保存，造成資源浪費，這就是假溢出現象。

//==========================

//使用自定義的queue接口

//隊列接口
public interface Queue {
    
    // 入隊
    public void append(Object obj) throws Exception;

    // 出隊
    public Object delete() throws Exception;

    // 獲得對頭元素
    public Object getFront() throws Exception;

    // 判斷是否為空
    public boolean isEmpty();

}

//循環鏈表的具體實現

/*
 * 循環順序隊列
 */
public class CircleSequenceQueue implements Queue {

    static final int defaultsize = 10;// 默認隊列的長度
    int front; // 對頭
    int rear; // 隊尾
    int count;// 統計元素個數的計數器
    int maxSize; // 隊的最大長度
    Object[] queue; // 隊列，使用數組實現

    // 默認構造
    public CircleSequenceQueue() {
        init(defaultsize);
    }

    public CircleSequenceQueue(int size) {
        // 通過給定長度進行構造
        init(size);
    }

    public void init(int size) {
        maxSize = size;
        front = rear = 0;
        count = 0;
        queue = new Object[size];
    }

    @Override
    public void append(Object obj) throws Exception {
        // TODO Auto-generated method stub
        if (count > 0 && front == rear) {
            throw new Exception("隊列已滿");
        }
        // 隊尾插入數據
        queue[rear] = obj;
        // 通過這種方法讓對標索引值不停的重復！！！
        rear = (rear + 1) % maxSize;
        count++;
    }

    @Override
    public Object delete() throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            throw new Exception("隊列為空");
        }
        // 去除對頭的元素，同時修改對頭的索引值
        Object obj = queue[front];
        // 對頭索引值，一樣通過+1驅魔運算來實現循環索引效果
        front = (front + 1) % maxSize;
        count--;
        return obj;
    }

    @Override
    public Object getFront() throws Exception {
        // TODO Auto-generated method stub
        if (!isEmpty()) {
            return queue[front];
        } else {
            // 對為空返回null
            return null;
        }
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return count == 0;
    }

}

//得到循環鏈表后，對其進行應用，之類主要是模擬賣票窗口

·  實例：使用順序循環隊列和多線程實現一個排隊買票的例子。

·  生產者（等候買票）

·  消費者 (買票離開)

//代碼的分割線，使用生產者消費者模式進行設計，主要是使用同步機制

//賣票窗口
public class WindowQueue {

    // 賣票的隊列默認長度10
    int maxSize = 10;
    CircleSequenceQueue queue = new CircleSequenceQueue(maxSize);
    // 用來統計賣票的數量，一天最多賣100張票？
    int num = 0;
    boolean isAlive = true; // 判斷是否繼續賣票

    // 排隊買票,使用同步機制
    public synchronized void producer() throws Exception {
        // count隊列中的元素個數，如果該值小於maxSize則可以買票
        if (queue.count < maxSize) {
            queue.append(num++); // 等待買票的數量+1
            System.out.println("第" + num + "個客戶排隊等待買票");
            this.notifyAll(); // 通知賣票線程可以賣票了
        }
        // 如果滿了
        else {
            try {

                System.out.println("隊列已滿...請等待");
                this.wait(); // 隊列滿時，排隊買票線程等待，其實等待賣票隊伍里面離開一個人后來喚醒自己

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    // 排隊賣票,使用同步機制
    public synchronized void consumer() throws Exception {
        // count隊列中的元素個數，如果該值大於0，則說明有票可以繼續賣票
        if (queue.count > 0) {

            Object obj = queue.delete();
            // 第幾個人買到票了
            int temp = Integer.parseInt(obj.toString());
            System.out.println("第" + (temp + 1) + "個客戶排隊買到票離開隊列");
            // 如果當前隊列為空，並且賣出票的數量的大於等於100說明賣票要結束
            if (queue.isEmpty() && this.num >= 100) {
                this.isAlive = false;
            }
            // 排隊隊伍離開一個人，可以進來一個人進行買票了。
            this.notifyAll(); // 通知買票線程可以買了，喚醒買票線程
        }
        // 如果滿了
        else {
            try {

                System.out.println("隊列已空...請進入隊伍准備買票");
                this.wait();// 隊列空時，排隊賣票線程等待，其實等待買票隊伍里面進來一個人后買票來喚醒自己

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

 

//下面的兩個類是生產者與消費者的具體實現，實現runnable接口

//買票者

public class Producer implements Runnable {
    // 買票窗口
    WindowQueue queue;

    // 保證和消費者使用同一個對象
    public Producer(WindowQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        //
        while (queue.num < 100) {
            try {
                //執行買票，消費者
                queue.producer();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

//賣票者
public class Consumer implements Runnable {
    WindowQueue queue;

    // 保證賣票與買票同步
    public Consumer(WindowQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        // 判斷是否可以繼續賣票
        while (queue.isAlive) {
            try {
                // 賣票
                queue.consumer();

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

 

 //測試。。。。。

public class Test {
    public static void main(String[] args) throws Exception {
        /*
         * CircleSequenceQueue queue = new CircleSequenceQueue();
         * queue.append("a"); queue.append("b"); queue.append("c");
         * queue.append("d"); queue.append("e");
         * 
         * while (!queue.isEmpty()) { System.out.print(queue.delete() + " "); }
         */

        // 賣票與買票模擬,使用同一個窗口對象
        WindowQueue queue = new WindowQueue();
        // 生產者
        Producer P = new Producer(queue);
        // 消費者
        Consumer c = new Consumer(queue);

        // 排隊買票線程
        Thread pThread = new Thread(P);
        // 買票線程
        Thread cThread = new Thread(c);

        pThread.start(); // 開始排隊買票
        cThread.start(); // 賣票
    }
}