一個系統是如何執行起來的？通過安卓的原始碼分析我們大概可以知道，Android在驅動層，在上層都採取生產-消費者模型來構建整個系統；因此對於生產-消費者模型的理解，就顯得十分重要；首先通過下圖，讓大家對生產-消費者模型有一個初步認識：

生產者負責向佇列提交任務，消費者從佇列取出任務，然後進行消費；
有人問，為什麼要設計個這麼個模型來用在軟體開發中；因為這個模型很簡單，很方便的將一個任務分解開來，有利於多執行緒的併發；有利於適應現代多核處理器，有利於現代作業系統通過分配時間片的方式來進行任務的執行；
生產-消費者模型的運用，有利於計算機更高效，更安全的管理利用唯一的硬體資源；
下面講解生產-消費者模型的實現要點：
（一）設計佇列
（二）設計提交任務的機制
（三）設計消費者消費模式
佇列的設計相對簡單，利用資料結構的知識就可以完成。
首先是佇列元素：

/**
 * 
 * @author 徐曄
 * @note 佇列元素
 */
public class Message {
    public Runnable runnable;
    public Message next;
    public LooperHandler mHandler;
    public int id;
    public boolean flag = false;

    public void recycle() {
        mHandler = null;
        next = null;
        runnable = null
 
;
    }

}

然後是佇列壓入，取出介面類：

public class MessageQueue {

    public Message start = null, end = null;
    private boolean waitflag = false;

    /** 構造佇列 */
    public MessageQueue() {
        // 初始化一個連結串列
        start = new Message();
        end = new Message();
        start.next = end;
        end.next = start;
    }

    /**
     * 判斷佇列是否為空
     */
 

    public boolean isempty() {
        // 當頭尾相遇時，佇列為空
        if (start.next == end) {
            return true;
        } else {
            return false;
        }
    }

    /** 給佇列插入任務 
     **  該方法是由生產者執行緒執行，因此需要在呼叫該方法的時候對佇列進行一個鎖操作
     */
    public void postMessage(Message msg) {
        System.out.println("插入任務");
        // 尾插法
        end.next.next = msg;
        msg.next = end;
        // 尾結點指向連結串列的最後一個元素
        end.next = msg;
        if (waitflag) {
            synchronized (this) {
                System.out.println("喚醒");
                //由於該物件在一個執行緒中執行，因此也就只有這麼一個執行緒在等待，因此呼叫的是notify();
                notify();
            }
        }
    }

    /**
     * 移除執行的元素
     */
    private void remove(Message msg) {
        start.next = msg.next;
        if (start.next == end) {
            end.next = start;
        }
    }

    /**
     * 獲取元素
     * 
     * @return
     */
    public Message next() {
        if (isempty()) {
            synchronized (this) {
                try {
                    waitflag = true;
                    System.out.println("進入等待");
                    //喚醒等待的執行緒
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("/**************************************************************/");
        System.out.println("獲取下一個訊息");
        waitflag = false;
        Message msg = start.next;
        remove(msg);
        return msg;
    }

}

第一個問題解決了，我們來看第二個問題：提交任務的機制？提交任務屬於生產者執行緒給消費者執行緒提交任務，因此我們需要獲取到消費者執行緒的任務佇列的提交任務的介面；
下面是我的實現：

public class Looper {

    /** 執行緒自帶的佇列 */
    private MessageQueue queue = null;
    /** 利用ThreadLocal來建立Thread和Looper的一一對應關係 */
    private static ThreadLocal<Looper> loopdata = new ThreadLocal<Looper>();

    private Looper() {

    }

    private void setQueue(MessageQueue queue) {
        this.queue = queue;
    }

    /** 初始化該執行緒的佇列 */
    public final static void prepare() {
        // 保證一個執行緒對應一個Looper,一個Looper包含一個MessageQueue
        if (loopdata.get() == null) {
            System.err.println("設定佇列");
            Looper l = new Looper();
            //引出MessageQueue 
            l.setQueue(new MessageQueue());
            loopdata.set(l);
        }
    }

    //獲取到和呼叫者執行緒對應的佇列
    public final static Looper get() {
        return loopdata.get();
    }

    /** 給消費者執行緒的佇列壓入資料 */
    void sendMessage(Message msg) {
        //佇列加鎖很重要
        synchronized (queue) {
            queue.postMessage(msg);
        }
    }

    /** 開始處理訊息 */
    public final static void Loop() {

        Looper loop = loopdata.get();
        MessageQueue mqueue = loop.queue;
        // 進入死迴圈，處理訊息
        for (;;) {
            Message msg = mqueue.next();
            if (msg.mHandler == null) {
                msg.mHandler = new LooperHandler(loop);
            }
            msg.mHandler.HandlerMessage(msg);
            msg.recycle();
        }
    }

}

佇列壓入介面和消費介面

public class LooperHandler {
    private Looper mLooper;

    public LooperHandler(Looper looper) {
        this.mLooper = looper;
    }

    /** 處理訊息 */
    void HandlerMessage(Message msg) {
        Runnable r=msg.runnable;
        if(r!=null){
            r.run();
        }
    }

    /** 將訊息壓入佇列 */
    public void sendMessage(Message msg) {
        mLooper.sendMessage(msg);
    }

}

好了，通過以上的構建，我們大概構造了生產–消費者模型：測試程式碼如下：

//生產者a
public class Producer implements Runnable {

    private LooperHandler handler;
    private int number = 0;

    public Producer(LooperHandler handler) {
        this.handler = handler;
    }

    @Override
    public void run() {
        while (true) {
            number++;
            final Message msg = new Message();
            msg.mHandler = handler;
            msg.id=number;
            msg.runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("Producer執行了第" + msg.id + "個任務");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO 自動生成的 catch 塊
                        e.printStackTrace();
                    }
                }
            };
            handler.sendMessage(msg);
            System.out.println("提交了" + number + "次");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

//生產者b

public class Producerb implements Runnable {

    private LooperHandler handler;
    private int number = 0;

    public Producerb(LooperHandler handler) {
        this.handler = handler;
    }

    @Override
    public void run() {
        while (true) {
            number++;
            final Message msg = new Message();
            msg.mHandler = handler;
            msg.id=number;
            msg.runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("Producerb執行了第" + msg.id + "個任務");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO 自動生成的 catch 塊
                        e.printStackTrace();
                    }
                }
            };
            handler.sendMessage(msg);
            System.out.println("提交了" + number + "次");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

測試：

public class Customer {

    public static void main(String[] args) {

        new Thread() {
            @Override
            public void run() {
                Looper.prepare();
                new Thread(new Producer(new LooperHandler(Looper.get()))).start();
                new Thread(new Producer(new LooperHandler(Looper.get()))).start();
                Looper.Loop();
                super.run();
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                Looper.prepare();
                new Thread(new Producerb(new LooperHandler(Looper.get()))).start();
                Looper.Loop();
                super.run();
            }
        }.start();


    }

}