某次面試阿里雲，要求實時寫一個小程式，要求如下：
1.兩個執行緒，一個執行緒生產者，一個執行緒是消費者
2.生產者生產票，超過10張就休息，被消費了就繼續生產。
3.消費者消費票，票沒了之後就休息，有票了接著消費。
題目看著很簡單，但卻包含了很多考點：訊息佇列、執行緒、執行緒通訊、鎖。
具體看看我寫的原始碼，這是後期幾經修改後的內容。

import java.util.LinkedList;
import java.util.NoSuchElementException;

public class AliTest {

    static String waitProp = new
 
 String();
    static MyQueue<String> q = new MyQueue<>();

     /**
     * 自定義一個Queue，實現先進後出
     * 其實LinkedList內部對queue的各個方法實現更精妙，可以直接只用，這裡主要為了抽出幾個關鍵方法和屬性來表達Queue的基礎原理
     */
    static class MyQueue<T> {
        //使用LinkedList作為Queue存放訊息
        private LinkedList<T> storage = new
 
 LinkedList<T>();

        public synchronized void push(T e) {//需要加上同步
            storage.addLast(e);
        }

        public T peek() {
            T t = null;
            try {
                t = storage.getFirst();
            } catch (NoSuchElementException e) {}
            return t;
        }

        public
 
 void pop() {
            storage.removeFirst();
        }

        public boolean empty() {
            return storage.isEmpty();
        }

        public int size() {
            return storage.size();
        }

        @Override
        public String toString() {
            return storage.toString();
        }
    }

    //生產者執行緒
    static class Provider extends Thread {

        @Override
        public void run() {
            while (true) {
                q.push("piao");
                System.out.println("加票");
                //每次生產完了之後通知一下等待中的生產者
                synchronized (waitProp) {
                    waitProp.notifyAll();
                }
                if (q.size() >= 10) {
                    System.out.println("加票滿了");

                    synchronized (waitProp) {
                        try {
                            waitProp.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                try {
                    Thread.sleep(300L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //消費者執行緒
    static class Comsumer extends Thread {

        @Override
        public synchronized void run() {
            while (true) {
                String a = q.peek();
                System.out.println("取票");
                //每次消費完了之後通知一下等待中的生產者
                synchronized (waitProp) {
                    waitProp.notifyAll();
                }
                if (a == null) {
                    System.out.println("取票沒了");

                    synchronized (waitProp) {
                        try {
                            waitProp.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                try {
                    Thread.sleep(500L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args){
        Provider p = new Provider();
        Comsumer c = new Comsumer();
        p.start();
        c.start();
    }
}

執行結果：

加票
取票
取票沒了
加票
加票
取票
加票
加票
... ...