有關Android線程的學習

1. Android進程

    在瞭解Android線程以前得先了解一下Android的進程。當一個程序第一次啓動的時候，Android會啓動一個LINUX進程和一個主線程。默認的狀況下，全部該程序的組件都將在該進程和線程中運行。同時，Android會爲每一個應用程序分配一個單獨的LINUX用戶。Android會盡可能保留一個正在運行進程，只在內存資源出現不足時，Android會嘗試中止一些進程從而釋放足夠的資源給其餘新的進程使用， 也能保證用戶正在訪問的當前進程有足夠的資源去及時地響應用戶的事件。Android會根據進程中運行的組件類別以及組件的狀態來判斷該進程的重要性，Android會首先中止那些不重要的進程。按照重要性從高到低一共有五個級別：

• 前臺進程
  前臺進程是用戶當前正在使用的進程。只有一些前臺進程能夠在任什麼時候候都存在。他們是最後一個被結束的，當內存低到根本連他們都不能運行的時候。通常來講， 在這種狀況下，設備會進行內存調度，停止一些前臺進程來保持對用戶交互的響應。
• 可見進程
  可見進程不包含前臺的組件可是會在屏幕上顯示一個可見的進程是的重要程度很高，除非前臺進程須要獲取它的資源，否則不會被停止。
• 服務進程
  運行着一個經過startService() 方法啓動的service，這個service不屬於上面提到的2種更高重要性的。service所在的進程雖然對用戶不是直接可見的，可是他們執行了用戶很是關注的任務（好比播放mp3，從網絡下載數據）。只要前臺進程和可見進程有足夠的內存，系統不會回收他們。
• 後臺進程
  運行着一個對用戶不可見的activity（調用過 onStop() 方法).這些進程對用戶體驗沒有直接的影響，能夠在服務進程、可見進程、前臺進 程須要內存的時候回收。一般，系統中會有不少不可見進程在運行，他們被保存在LRU (least recently used) 列表中，以便內存不足的時候被第一時間回收。若是一個activity正 確的執行了它的生命週期，關閉這個進程對於用戶體驗沒有太大的影響。
• 空進程
  未運行任何程序組件。運行這些進程的惟一緣由是做爲一個緩存，縮短下次程序須要從新使用的啓動時間。系統常常停止這些進程，這樣能夠調節程序緩存和系統緩存的平衡。

    Android 對進程的重要性評級的時候，選取它最高的級別。另外，當被另外的一個進程依賴的時候，某個進程的級別可能會增高。一個爲其餘進程服務的進程永遠不會比被服務的進程重要級低。由於服務進程比後臺activity進程重要級高，所以一個要進行耗時工做的activity最好啓動一個service來作這個工做，而不是開啓一個子進程――特別是這個操做須要的時間比activity存在的時間還要長的時候。例如，在後臺播放音樂，向網上上傳攝像頭拍到的圖片，使用service可使進程最少獲取到「服務進程」級別的重要級，而不用考慮activity目前是什麼狀態。broadcast receivers作費時的工做的時候，也應該啓用一個服務而不是開一個線程。

 

2. 單線程模型

    當一個程序第一次啓動時，Android會同時啓動一個對應的主線程（Main Thread），主線程主要負責處理與UI相關的事件，如用戶的按鍵事件，用戶接觸屏幕的事件以及屏幕繪圖事件，並把相關的事件分發到對應的組件進行處理。因此主線程一般又被叫作UI線程。在開發Android應用時必須遵照單線程模型的原則： Android UI操做並非線程安全的而且這些操做必須在UI線程中執行。

 

2.1 子線程更新UI

    Android的UI是單線程(Single-threaded)的。爲了不拖住GUI，一些較費時的對象應該交給獨立的線程去執行。若是幕後的線程來執行UI對象，Android就會發出錯誤訊息 CalledFromWrongThreadException。之後遇到這樣的異常拋出時就要知道怎麼回事了！

 

2.2 Message Queue

     在單線程模型下，爲了解決相似的問題，Android設計了一個Message Queue(消息隊列)， 線程間能夠經過該Message Queue並結合Handler和Looper組件進行信息交換。下面將對它們進行分別介紹：

     1. Message

    Message消息，理解爲線程間交流的信息，處理數據後臺線程須要更新UI，則發送Message內含一些數據給UI線程。

 

     2. Handler

    Handler處理者，是Message的主要處理者，負責Message的發送，Message內容的執行處理。後臺線程就是經過傳進來的Handler對象引用來 sendMessage(Message)。而使用Handler，須要implement 該類的  handleMessage(Message)方法，它是處理這些Message的操做內容，例如Update UI。一般須要子類化Handler來實現handleMessage方法。

 

     3. Message Queue

    Message Queue消息隊列，用來存放經過Handler發佈的消息，按照先進先出執行。

    每一個message queue都會有一個對應的Handler。Handler會向message queue經過兩種方法發送消息：sendMessage或post。這兩種消息都會插在message queue隊尾並按先進先出執行。但經過這兩種方法發送的消息執行的方式略有不一樣：經過sendMessage發送的是一個message對象,會被Handler的handleMessage()函數處理；而經過post方法發送的是一個runnable對象，則會本身執行。

 

     4. Looper

    Looper是每條線程裏的Message Queue的管家。Android沒有Global的Message Queue，而Android會自動替主線程(UI線程)創建Message Queue，但在子線程裏並無創建Message Queue。因此調用Looper.getMainLooper()獲得的主線程的Looper不爲NULL，但調用Looper.myLooper()獲得當前線程的Looper就有可能爲NULL。

    對於子線程使用Looper，API Doc提供了正確的使用方法：

class LooperThread extends Thread {
    public Handler mHandler;

    public void run() {
        Looper.prepare(); //建立本線程的Looper並建立一個MessageQueue

        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };

        Looper.loop(); //開始運行Looper,監聽Message Queue
    }
}

 

    這個Message機制的大概流程：

    1. 在Looper.loop()方法運行開始後，循環地按照接收順序取出Message Queue裏面的非NULL的Message。

    2. 一開始Message Queue裏面的Message都是NULL的。當Handler.sendMessage(Message)到Message Queue，該函數裏面設置了那個Message對象的target屬性是當前的Handler對象。隨後Looper取出了那個Message，則調用該Message的target指向的Hander的dispatchMessage函數對Message進行處理。

    在dispatchMessage方法裏，如何處理Message則由用戶指定，三個判斷，優先級從高到低：

    1) Message裏面的Callback，一個實現了Runnable接口的對象，其中run函數作處理工做；

    2) Handler裏面的mCallback指向的一個實現了Callback接口的對象，由其handleMessage進行處理；

    3) 處理消息Handler對象對應的類繼承並實現了其中handleMessage函數，經過這個實現的handleMessage函數處理消息。

    因而可知，咱們實現的handleMessage方法是優先級最低的！

    3. Handler處理完該Message (update UI) 後，Looper則設置該Message爲NULL，以便回收！

 

    在網上有不少文章講述主線程和其餘子線程如何交互，傳送信息，最終誰來執行處理信息之類的，我的理解是最簡單的方法——判斷Handler對象裏面的Looper對象是屬於哪條線程的，則由該線程來執行！

    1. 當Handler對象的構造函數的參數爲空，則爲當前所在線程的Looper；

    2. Looper.getMainLooper()獲得的是主線程的Looper對象，Looper.myLooper()獲得的是當前線程的Looper對象。

如今來看一個例子，模擬從網絡獲取數據，加載到ListView的過程：

public class ListProgressDemo extends ListActivity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.listprogress);

        ((Button) findViewById(R.id.load_Handler)).setOnClickListener(new View.OnClickListener(){

            @Override
            public void onClick(View view) {
                data = null;
                data = new ArrayList<String>();

                adapter = null;

                showDialog(PROGRESS_DIALOG);
                new ProgressThread(handler, data).start();
            }
        });
    }

    @Override
    protected Dialog onCreateDialog(int id) {
        switch(id) {
        case PROGRESS_DIALOG:
                 return ProgressDialog.show(this, "",
                   "Loading. Please wait...", true);

        default: return null;
        }
    }

    private class ProgressThread extends Thread {

        private Handler handler;
        private ArrayList<String> data;

        public ProgressThread(Handler handler, ArrayList<String> data) {
            this.handler = handler;
            this.data = data;
        }

        @Override
        public void run() {
            for (int i=0; i<8; i++) {
                data.add("ListItem"); //後臺數據處理
                try {
                    Thread.sleep(100);
                }catch(InterruptedException e) {

                    Message msg = handler.obtainMessage();
                    Bundle b = new Bundle();
                    b.putInt("state", STATE_ERROR);
                    msg.setData(b);
                    handler.sendMessage(msg);

                }
            }
            Message msg = handler.obtainMessage();
            Bundle b = new Bundle();
            b.putInt("state", STATE_FINISH);
            msg.setData(b);
            handler.sendMessage(msg);
        }

    }

    // 此處甚至能夠不須要設置Looper，由於Handler默認就使用當前線程的Looper
    private final Handler handler = new Handler(Looper.getMainLooper()) {

        public void handleMessage(Message msg) { // 處理Message，更新ListView
            int state = msg.getData().getInt("state");
            switch(state){
                case STATE_FINISH:
                    dismissDialog(PROGRESS_DIALOG);
                    Toast.makeText(getApplicationContext(),
                            "加載完成!",
                            Toast.LENGTH_LONG)
                         .show();

                    adapter = new ArrayAdapter<String>(getApplicationContext(),
                            android.R.layout.simple_list_item_1,
                            data );

                    setListAdapter(adapter);

                    break;

                case STATE_ERROR:
                   dismissDialog(PROGRESS_DIALOG);
                   Toast.makeText(getApplicationContext(),
                           "處理過程發生錯誤!",
                           Toast.LENGTH_LONG)
                        .show();

                   adapter = new ArrayAdapter<String>(getApplicationContext(),
                           android.R.layout.simple_list_item_1,
                           data );

                      setListAdapter(adapter);

                      break;

               default:

            }
        }
    };


    private ArrayAdapter<String> adapter;
    private ArrayList<String> data;

    private static final int PROGRESS_DIALOG = 1;
    private static final int STATE_FINISH = 1;
    private static final int STATE_ERROR = -1;
}

這個例子，我本身寫完後以爲仍是有點亂，要稍微整理才能看明白線程間交互的過程以及數據的先後變化。隨後瞭解到AsyncTask類，相應修改後就很容易明白了！

 

2.3 AsyncTask

AsyncTask版：

((Button) findViewById(R.id.load_AsyncTask)).setOnClickListener(new View.OnClickListener(){

    @Override
    public void onClick(View view) {
        data = null;
        data = new ArrayList<String>();

        adapter = null;

        //顯示ProgressDialog放到AsyncTask.onPreExecute()裏
        //showDialog(PROGRESS_DIALOG);
        new ProgressTask().execute(data);
    }
});

private class ProgressTask extends AsyncTask<ArrayList<String>, Void, Integer> {

/* 該方法將在執行實際的後臺操做前被UI thread調用。能夠在該方法中作一些準備工做，如在界面上顯示一個進度條。*/
@Override
protected void onPreExecute() {
    // 先顯示ProgressDialog
    showDialog(PROGRESS_DIALOG);
}

/* 執行那些很耗時的後臺計算工做。能夠調用publishProgress方法來更新實時的任務進度。 */
@Override
protected Integer doInBackground(ArrayList<String>... datas) {
    ArrayList<String> data = datas[0];
    for (int i=0; i<8; i++) {
        data.add("ListItem");
    }
    return STATE_FINISH;
}

/* 在doInBackground 執行完成後，onPostExecute 方法將被UI thread調用，
 * 後臺的計算結果將經過該方法傳遞到UI thread.
 */
@Override
protected void onPostExecute(Integer result) {
    int state = result.intValue();
    switch(state){
    case STATE_FINISH:
        dismissDialog(PROGRESS_DIALOG);
        Toast.makeText(getApplicationContext(),
                "加載完成!",
                Toast.LENGTH_LONG)
             .show();

        adapter = new ArrayAdapter<String>(getApplicationContext(),
                android.R.layout.simple_list_item_1,
                data );

        setListAdapter(adapter);

        break;

    case STATE_ERROR:
       dismissDialog(PROGRESS_DIALOG);
       Toast.makeText(getApplicationContext(),
               "處理過程發生錯誤!",
               Toast.LENGTH_LONG)
            .show();

       adapter = new ArrayAdapter<String>(getApplicationContext(),
               android.R.layout.simple_list_item_1,
               data );

          setListAdapter(adapter);

          break;

   default:

   }
}

    Android另外提供了一個工具類：AsyncTask。它使得UI thread的使用變得異常簡單。它使建立須要與用戶界面交互的長時間運行的任務變得更簡單，不須要藉助線程和Handler便可實現。

    1)  子類化AsyncTask

    2)  實現AsyncTask中定義的下面一個或幾個方法

         onPreExecute() 開始執行前的準備工做；

         doInBackground(Params...) 開始執行後臺處理，能夠調用publishProgress方法來更新實時的任務進度；

         onProgressUpdate(Progress...)  在publishProgress方法被調用後，UI thread將調用這個方法從而在界面上展現任務的進展狀況，例如經過一個進度條進行展現。

         onPostExecute(Result) 執行完成後的操做，傳送結果給UI 線程。

 

         這4個方法都不能手動調用。並且除了doInBackground(Params...)方法，其他3個方法都是被UI線程所調用的，因此要求：

        1) AsyncTask的實例必須在UI thread中建立；

        2) AsyncTask.execute方法必須在UI thread中調用；

        

    同時要注意：該task只能被執行一次，不然屢次調用時將會出現異常。並且是不能手動中止的，這一點要注意，看是否符合你的需求！

 

    在使用過程當中，發現AsyncTask的構造函數的參數設置須要看明白： AsyncTask<Params, Progress, Result>

    Params對應doInBackground(Params...)的參數類型。而new AsyncTask().execute(Params... params)，就是傳進來的Params數據，你能夠execute(data)來傳送一個數據，或者execute(data1, data2, data3)這樣多個數據。

    Progress對應onProgressUpdate(Progress...)的參數類型；

    Result對應onPostExecute(Result)的參數類型。

    當以上的參數類型都不須要指明某個時，則使用Void，注意不是void。不明白的能夠參考上面的例子，或者API Doc裏面的例子。

 

----------------

本文的至關內容摘錄於《 淺析Android線程模型一 --- 轉》，但對於Message機制的流程理解則在參考《 android中Message機制的靈活應用》後修改了！