Android教程網
設為首頁|加入收藏
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> Android開發實例 >> 有關Android線程的學習

有關Android線程的學習

編輯：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提供了正確的使用方法：

  1. class LooperThread extends Thread { 
  2.     public Handler mHandler; 
  3.  
  4.     public void run() { 
  5.         Looper.prepare(); //創建本線程的Looper並創建一個MessageQueue
  6.  
  7.         mHandler = new Handler() { 
  8.             public void handleMessage(Message msg) { 
  9.                 // process incoming messages here 
  10.             } 
  11.         }; 
  12.    
  13.         Looper.loop(); //開始運行Looper,監聽Message Queue 
  14.     } 
  15. } 
 

    這個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的過程：

  1. public class ListProgressDemo extends ListActivity { 
  2.  
  3.     @Override 
  4.     public void onCreate(Bundle savedInstanceState) { 
  5.         super.onCreate(savedInstanceState); 
  6.         setContentView(R.layout.listprogress); 
  7.  
  8.         ((Button) findViewById(R.id.load_Handler)).setOnClickListener(new View.OnClickListener(){ 
  9.  
  10.             @Override 
  11.             public void onClick(View view) { 
  12.                 data = null; 
  13.                 data = new ArrayList<String>(); 
  14.  
  15.                 adapter = null; 
  16.  
  17.                 showDialog(PROGRESS_DIALOG); 
  18.                 new ProgressThread(handler, data).start(); 
  19.             } 
  20.         }); 
  21.     } 
  22.  
  23.     @Override 
  24.     protected Dialog onCreateDialog(int id) { 
  25.         switch(id) { 
  26.         case PROGRESS_DIALOG: 
  27.                  return ProgressDialog.show(this, "",  
  28.                    "Loading. Please wait...", true); 
  29.  
  30.         default: return null; 
  31.         } 
  32.     } 
  33.  
  34.     private class ProgressThread extends Thread { 
  35.  
  36.         private Handler handler; 
  37.         private ArrayList<String> data; 
  38.  
  39.         public ProgressThread(Handler handler, ArrayList<String> data) { 
  40.             this.handler = handler; 
  41.             this.data = data; 
  42.         } 
  43.  
  44.         @Override 
  45.         public void run() { 
  46.             for (int i=0; i<8; i++) { 
  47.                 data.add("ListItem"); //後台數據處理
  48.                 try { 
  49.                     Thread.sleep(100); 
  50.                 }catch(InterruptedException e) { 
  51.                      
  52.                     Message msg = handler.obtainMessage(); 
  53.                     Bundle b = new Bundle(); 
  54.                     b.putInt("state", STATE_ERROR); 
  55.                     msg.setData(b); 
  56.                     handler.sendMessage(msg);  
  57.                      
  58.                 } 
  59.             } 
  60.             Message msg = handler.obtainMessage(); 
  61.             Bundle b = new Bundle(); 
  62.             b.putInt("state", STATE_FINISH); 
  63.             msg.setData(b); 
  64.             handler.sendMessage(msg); 
  65.         } 
  66.          
  67.     } 
  68.  
  69.     // 此處甚至可以不需要設置Looper，因為Handler默認就使用當前線程的Looper
  70.     private final Handler handler = new Handler(Looper.getMainLooper()) {
  71.  
  72.         public void handleMessage(Message msg) { // 處理Message，更新ListView
  73.             int state = msg.getData().getInt("state"); 
  74.             switch(state){ 
  75.                 case STATE_FINISH: 
  76.                     dismissDialog(PROGRESS_DIALOG); 
  77.                     Toast.makeText(getApplicationContext(), 
  78.                             "加載完成!", 
  79.                             Toast.LENGTH_LONG) 
  80.                          .show(); 
  81.  
  82.                     adapter = new ArrayAdapter<String>(getApplicationContext(), 
  83.                             android.R.layout.simple_list_item_1, 
  84.                             data ); 
  85.                              
  86.                     setListAdapter(adapter); 
  87.  
  88.                     break; 
  89.  
  90.                 case STATE_ERROR: 
  91.                    dismissDialog(PROGRESS_DIALOG); 
  92.                    Toast.makeText(getApplicationContext(), 
  93.                            "處理過程發生錯誤!", 
  94.                            Toast.LENGTH_LONG) 
  95.                         .show(); 
  96.  
  97.                    adapter = new ArrayAdapter<String>(getApplicationContext(), 
  98.                            android.R.layout.simple_list_item_1, 
  99.                            data ); 
  100.                             
  101.                       setListAdapter(adapter); 
  102.  
  103.                       break; 
  104.  
  105.                default: 
  106.  
  107.             } 
  108.         } 
  109.     }; 
  110.  
  111.  
  112.     private ArrayAdapter<String> adapter; 
  113.     private ArrayList<String> data; 
  114.  
  115.     private static final int PROGRESS_DIALOG = 1; 
  116.     private static final int STATE_FINISH = 1; 
  117.     private static final int STATE_ERROR = -1; 
  118. } 

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

 

2.3 AsyncTask

AsyncTask版： 
  1. ((Button) findViewById(R.id.load_AsyncTask)).setOnClickListener(new View.OnClickListener(){ 
  2.  
  3.     @Override 
  4.     public void onClick(View view) { 
  5.         data = null; 
  6.         data = new ArrayList<String>(); 
  7.  
  8.         adapter = null; 
  9.  
  10.         //顯示ProgressDialog放到AsyncTask.onPreExecute()裡 
  11.         //showDialog(PROGRESS_DIALOG); 
  12.         new ProgressTask().execute(data); 
  13.     } 
  14. }); 
  15.  
  16. private class ProgressTask extends AsyncTask<ArrayList<String>, Void, Integer> { 
  17.  
  18. /* 該方法將在執行實際的後台操作前被UI thread調用。可以在該方法中做一些准備工作，如在界面上顯示一個進度條。*/ 
  19. @Override 
  20. protected void onPreExecute() { 
  21.     // 先顯示ProgressDialog
  22.     showDialog(PROGRESS_DIALOG); 
  23. } 
  24.  
  25. /* 執行那些很耗時的後台計算工作。可以調用publishProgress方法來更新實時的任務進度。 */ 
  26. @Override 
  27. protected Integer doInBackground(ArrayList<String>... datas) { 
  28.     ArrayList<String> data = datas[0]; 
  29.     for (int i=0; i<8; i++) { 
  30.         data.add("ListItem"); 
  31.     } 
  32.     return STATE_FINISH; 
  33. } 
  34.  
  35. /* 在doInBackground 執行完成後，onPostExecute 方法將被UI thread調用， 
  36.  * 後台的計算結果將通過該方法傳遞到UI thread. 
  37.  */ 
  38. @Override 
  39. protected void onPostExecute(Integer result) { 
  40.     int state = result.intValue(); 
  41.     switch(state){ 
  42.     case STATE_FINISH: 
  43.         dismissDialog(PROGRESS_DIALOG); 
  44.         Toast.makeText(getApplicationContext(), 
  45.                 "加載完成!", 
  46.                 Toast.LENGTH_LONG) 
  47.              .show(); 
  48.  
  49.         adapter = new ArrayAdapter<String>(getApplicationContext(), 
  50.                 android.R.layout.simple_list_item_1, 
  51.                 data ); 
  52.                  
  53.         setListAdapter(adapter); 
  54.  
  55.         break; 
  56.          
  57.     case STATE_ERROR: 
  58.        dismissDialog(PROGRESS_DIALOG); 
  59.        Toast.makeText(getApplicationContext(), 
  60.                "處理過程發生錯誤!", 
  61.                Toast.LENGTH_LONG) 
  62.             .show();
  63.  
  64.        adapter = new ArrayAdapter<String>(getApplicationContext(), 
  65.                android.R.layout.simple_list_item_1, 
  66.                data );
  67.  
  68.           setListAdapter(adapter);
  69.  
  70.           break;
  71.  
  72.    default:
  73.  
  74.    }
  75. }

    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機制的靈活應用》後修改了！
  1. 上一頁:
  2. 下一頁:
Android開發實例
Android編程入門Android技術基礎Android資訊關於Android編程Android開發Android開發環境Android開發實例
相關文章
熱門文章
Android實現多線程下載文件的方法 Android從源碼的角度徹底理解事件分發機制(下) Android中斷線程的處理方法 【Android游戲開發之一】設置全屏以及繪畫簡單的圖形 Android中文API（143） —— CountDownTimer Android登錄實例
Android ApiDemo示例解讀系列之一：怎樣創建ApiDemo示例工程

    &nb
Android本地化

Android應用程序可以在許多不同地區的許多設備上運行。為了使應用程序
Android登錄實例

登錄應用程序的屏幕，詢問憑據登錄到一些特定的應用。可能需要登錄到Face
android LinearLayout和RelativeLayout組合實現精確布局方法介紹

先明確幾個概念的區別： padding margin都是邊距的含
閱讀排行版
Copyright © Android教程網 All Rights Reserved