Android--線程詳解

什麼是線程？

線程或者線程執行本質上就是一串指令（也是程式代碼），然後我們把它發送給作業系統執行。

http://jbcdn2.b0.upaiyun.com/2014/07/06ef278da3a44e076b8f06dada6c3624.png

一般來說，我們的CPU在任何時候一個核隻能處理一個線程。多核處理器（目前大多數Android裝置已經都是多核）顧名思義，就是可以同時處理多線程（通俗地講就是可以同時處理多件事）。

多核處理與單核多任務處理的實質

上面我說的是一般情況，并不是所有的描述都是一定正确的。因為單核也可以用多任務模拟出多線程。

每個運作線上程中的任務都可以分解成多條指令，而且這些指令不用同時執行。是以，單核裝置可以首先切換到線程1去執行指令1A，然後切換到線程2去執行指令2A，接着傳回到線程1再去執行1B、1C、1D，然後繼續切換到線程2，執行2B、2C等等，以此類推。

這個線程之間的切換十分迅速，以至于在單核的裝置中也會發生。幾乎所有的線程都在相同的時間内進行任務處理。其實，這都是因為速度太快造成的假象，就像電影《黑客帝國》裡的特工Brown一樣，可以變幻出很多的頭和手。

接下來我們來看一些代碼。

Java核心裡的線程

在Java中，如果要想做平行任務處理的話，會在Runnable裡面執行你的代碼。可以繼承Thread類，或者實作Runnable接口：

// Version 1
public class IAmAThread extends Thread {
    public IAmAThread() {
        super("IAmAThread");
    }
 
    @Override
    public void run() {
        
// your code (sequence of instructions)
    }
}
// to execute this sequence of instructions in a separate thread.
new IAmAThread().start();
 
// Version 2
public class IAmARunnable implements Runnable {
    @Override
    public void run() {
        
// your code (sequence of instructions)
    }
}
// to execute this sequence of instructions in a separate thread.
IAmARunnable myRunnable = new IAmARunnable();
new Thread(myRunnable).start();

這兩個方法基本上是一樣的。第一個版本是建立一個Thread類，第二個版本是需要建立一個Runnable對象，然後也需要一個Thread類來調用它。

第二個版是通常建議使用的方法。這也是一個很大的主題了，超過了本文的範圍，以後會再做讨論。

Android上的線程

無論何時啟動APP，所有的元件都會運作在一個單獨的線程中（預設的）——叫做主線程。這個線程主要用于處理UI的操作并為視圖元件和小部件分發事件等，是以主線程也被稱作UI線程。

如果你在UI線程中運作一個耗時操作，那麼UI就會被鎖住，直到這個耗時操作結束。對于使用者體驗來說，這是非常糟糕的！這也就是為什麼我們要了解Android上的線程機制了。了解這些機制就可以把一些複雜的工作移動到其它的線程中去執行。如果你在UI線程中運作一個耗時的任務，那麼很有可能會發生ANR（應用無響應），這樣使用者就會很快地結束掉你的APP。

Android和Java一樣，它支援使用Java裡面的Thread類來進行一步任務處理。是以可以輕松地像上面Java的例子一樣來使用Android上的線程，不過那好像還是有點困難。

為什麼在Android上使用标準Java的線程會困難呢？

其實平行任務處理沒有想象中的那麼簡單，你必須在多線程中保證并發，就像偉大的Tim Bray說的那樣：ordinary humans can’t do concurrency at scale (or really at all) …

特别對于Android來說，以下這些功能就略顯臃腫：

異步對于UI線程來說是一個主要的PITA（如果你需要在背景線程中向主線程更新界面，那麼你就會用到）。
如果螢幕方向或者螢幕配置改變的話，就會出現一些更加奇怪的現象。因為改變螢幕方向，會引起Activity重建（是以背景線程就需要去改變被銷毀的Activity的狀态了，而如果背景線程不是在UI線程之上的話，那情況會更加複雜，原因如條件1）。
對于線程池來說，沒有預設的處理方式。
取消線程操作需要自定義代碼實作。

那麼在Android上怎麼進行任務并發處理呢？

你可能聽過一些Android上一些常見的名詞：

1、Handler

這就是我們今天要讨論的詳細主題。

2、AsyncTask

使用AsyncTask是在Android上操作線程最簡單的方式，也是最容易出錯的方式。

3、IntentService

這種方式需要寫更多的代碼，但是這是把耗時任務移動到背景的很好的方式，也是我最喜歡的方式。配上使用一個EventBus機制的架構如

Otto

，這樣的話實作IntentService就非常簡單了。

4、Loader

關于處理異步任務，還有很多事情需要做，比如從資料庫或者内容提供者那裡處理一些資料。

5、Service

如果你曾經使用過Service的話，你應該知道這裡會有一點誤區，其中一個常見的誤解就是服務是運作在背景線程的。其實不是！看似運作在背景是因為它們不與UI元件關聯，但是它們（預設）是運作在UI線程上的……是以預設運作在UI線程上，甚至在上面沒有UI部件。

如果想要把服務運作在背景線程中，那麼必須自定義一個線程，然後把操作代碼都運作在那個線程中（與上面提到的方法很類似）。事實上你應該使用IntentService實作，但是這不是本文讨論的主題。

Android上的Handler

以下是從

Android developer documentation for Handlers:

中摘選的一段話：

> A Handler allows you to send and process Message and Runnable objects associated with a thread’s MessageQueue. Each Handler instance is associated with a single thread and that thread’s message queue. When you create a new Handler, it is bound to the thread/message

queue of the thread that is creating it — from that point on, it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.

為了更好地了解這個概念，也許你需要去看看什麼是Message Queues。

消息隊列

線上程裡基本都有一個叫做“消息隊列”的東西，它負責線程間通信。這是一種設計模式，所有控制指令或者内容線上程間傳遞。

消息隊列如同它的名字那樣，對于線程來說，它就是一個指令隊列。這裡我們還可以做一些更酷的事：

定時消息和線程在某個時間點才執行。
需要在另一個線程中去添加入隊動作，而不是在本線程中。

注意：這裡說的“消息”和Runnable對象、指令隊列的概念是一樣的。

回到Android上的Handler……如果你仔細閱讀的話，可以看到文檔是這樣說的：

> A Handler allows you to send and process Message and Runnable objects associated with a thread’s MessageQueue.

是以Handler可以讓你給線程隊列發消息：

> Each Handler instance is associated with a single thread and that thread’s message queue.

一個Handler對象隻能和一個線程關聯：

> When you create a new Handler, it is bound to the thread / message queue of the thread that is creating it

是以一個Handler到底和哪個線程關聯呢？就是創造它的線程。

> — from that point on, it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.、

在我們了解這些知識後，請繼續看……

小貼士：這裡有幾點可能你還不知道。每個線程都和一個Handler類執行個體綁定，而且可以和别的線程一起運作，互相通信。

還有一個小建議（如果用過AsyncTask的話），AsyncTask内部也是使用Handler進行處理的，隻是不是運作在UI線程而已，它會提供一個channel來和UI線程通信，使用postExecute方法即可實作。

這還挺酷的，那怎麼建立Handler呢？

有兩種方式：

使用預設的構造方法：new Handler()。
使用帶參的構造方法，參數是一個Runnable對象或者回調對象。

Handler裡面有什麼實用的API嗎？

請記住：

Handler隻是簡單往消息隊列中發送消息而已（或者使用post方式）
它們有更友善的方法可以幫助與UI線程通信。

如果你現在看看

Handler的API

，可以清楚看到這幾個方法：

post
postDelayed
postAtTime

代碼示例

這裡的代碼都是很基礎的，不過你可以好好看看注釋。

示例1：使用Handler的“post”方法

public class TestActivity extends Activity {
 
// ...
// all standard stuff
 
@Override
public void onCreate(Bundle savedInstanceState) {
 
    
// ...
    
// all standard stuff
 
    
// we're creating a new handler here
    
// and we're in the UI Thread (default)
    
// so this Handler is associated with the UI thread
    Handler mHandler = new Handler();
 
    
// I want to start doing something really long
    
// which means I should run the fella in another thread.
    
// I do that by sending a message - in the form of another runnable object
 
    
// But first, I'm going to create a Runnable object or a message for this
    Runnable mRunnableOnSeparateThread = new Runnable() {
        @Override
        public void run () {
 
            
// do some long operation
            longOperation();
 
            
// After mRunnableOnSeparateThread is done with it's job,
            
// I need to tell the user that i'm done
            
// which means I need to send a message back to the UI thread
 
            
// who do we know that's associated with the UI thread?
            mHandler.post(new Runnable(){
                @Override
                public void run(){
                    
// do some UI related thing
                    
// like update a progress bar or TextView
                    
// ....
                }
            });
 
 
        }
    };
 
    
// Cool but I've not executed the mRunnableOnSeparateThread yet
    
// I've only defined the message to be sent
    
// When I execute it though, I want it to be in a different thread
    
// that was the whole point.
 
    new Thread(mRunnableOnSeparateThread).start();
}
 
}

如果根本就沒有Handler對象，回調post方法會比較難辦。

示例2：使用postDelayed方法

近期本站新介紹的特性中，我每次都要模拟EditText的自動完成功能，每次文字改變後都會觸發一個API的調用，從伺服器中檢索資料。

我想減少APP調用API的次數，是以決定使用Handler的postDelayed方法來實作這個功能。

本例不針對平行處理，隻是關于Handler給消息隊列發送消息還有安排消息在未來的某一點執行等。

// the below code is inside a TextWatcher
// which implements the onTextChanged method
// I've simplified it to only highlight the parts we're
// interested in
 
private long lastChange = 0;
 
@Override
public void onTextChanged(final CharSequence chars,
                          int start, int before, int count) {
 
        
// The handler is spawned from the UI thread
        new Handler().postDelayed(
 
            
// argument 1 for postDelated = message to be sent
            new Runnable() {
                @Override
                public void run() {
 
                    if (noChangeInText_InTheLastFewSeconds()) {
                        searchAndPopulateListView(chars.toString());  
// logic
                    }
                }
            },
 
            
// argument 2 for postDelated = delay before execution
            300);
 
        lastChange = System.currentTimeMillis();
}
 
 
private boolean noChangeInText_InTheLastFewSeconds() {
    return System.currentTimeMillis() - lastChange >= 300
}

最後我就把“postAtTime”這個方法作為聯系留給讀者們了，掌握Handler了嗎？如果是的話，那麼可以盡情使用線程了。

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--線程詳解

什麼是線程？

多核處理與單核多任務處理的實質

Java核心裡的線程

Android上的線程

為什麼在Android上使用标準Java的線程會困難呢？

Android上的Handler

消息隊列

這還挺酷的，那怎麼建立Handler呢？

Handler裡面有什麼實用的API嗎？

代碼示例

1. Android程序

2. 單線程模型

2.1 子線程更新UI

2.2 Message Queue

2.3 AsyncTask

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

Android電視機（機頂盒）初次開發的一些經驗分享

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method