1、問題提出
1）為何需要多線程？
2）多線程如何實現？
3）多線程機制的核心是啥？
4）到底有多少種實現方式？

2、問題分析
1）究其為啥需要多線程的本質就是異步處理，直觀一點說就是不要讓用戶感覺到“很卡”。
eg:你點擊按鈕下載一首歌，接著該按鈕一直處于按下狀態，那么用戶體驗就很差。

2）多線程實現方式implements Runnable 或 extends Thread

3）多線程核心機制是Handler

4）提供如下幾種實現方式
—-1—–Handler
————————————說明1
創建一個Handler時一定要關聯一個Looper實例，默認構造方法Handler()，它是關聯當前Thread的Looper。
eg:
我們在UI Thread中創建一個Handler,那么此時就關聯了UI Thread的Looper！
這一點從源碼中可以看出！
精簡代碼如下：

復制代碼 代碼如下:

public Handler() {
mLooper = Looper.myLooper();
//當前線程的Looper，在Activity創建時，UI線程已經創建了Looper對象
//在Handler中機制中Looper是最為核心的，它一直處于循環讀MessageQueue，有
//要處理的Message就將Message發送給當前的Handler實例來處理

if (mLooper == null) {
throw new RuntimeException(
“Can't create handler inside thread that has not called Looper.prepare()”);
}
//從以上可以看出，一個Handler實例必須關聯一個Looper對象，否則出錯

mQueue = mLooper.mQueue;
//Handler的MessageQueue，它是FIFO的嗎？不是！我感覺應該是按時間先后排列
//的！Message與MessageQueue到底是啥關系？感興趣可以研究一下源碼！

mCallback = null;
}

在創建一個Handler的時候也可以指定Looper，此時的Looper對象，可以是當前線程的也可以是其它線程的！
Handler只是處理它所關聯的Looper中的MessageQueue中的Message，至于它哪個線程的Looper，Handler并不是很關心！
eg:
我們在UI線程中創建了Handler實例，此時傳進Worker線程的Looper，此時依然可以進行業務操作！
eg:
——————–創建工作者線程

復制代碼 代碼如下:

private static final class Worker implements Runnable
{
private static final Object mLock = new Object() ;
private Looper mLooper ;

public Worker(String name)
{
final Thread thread = new Thread(null,this,name) ;
thread.setPriority(Thread.MIN_PRIORITY) ;
thread.start() ;

synchronized(mLock)
{
while(mLooper == null)
{
try
{
mLock.wait() ;
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}

@Override
public void run() {
synchronized(mLock)
{
//該方法只能執行一次,一個Thread只能關聯一個Looper
Looper.prepare() ;
mLooper = Looper.myLooper() ;
mLock.notifyAll() ;
}
Looper.loop() ;
}

public Looper getLooper()
{
return mLooper ;
}

public void quit()
{
mLooper.quit() ;
}
}

我們可以在UI線程中創建一個Handler同時傳入Worker的Looper
eg:
—————-定義自己的Handler

復制代碼 代碼如下:

private final class MyHandler extends Handler
{
private long id ;

public MyHandler(Looper looper)
{
super(looper) ;
}

@Override
public void handleMessage(Message msg) {
switch(msg.what)
{
case 100 :
mTv.setText(“” + id) ;
break ;
}
}
}

———在Activity中創建Handler
this.mWorker = new Worker(“workerThread”) ;
this.mMyHandler = new MyHandler(this.mWorker.getLooper()) ;

———創建Message
final Message msg = this.mMyHandler.obtainMessage(100);
msg.put(“test” , “test”) ;
msg.sendToTarget() ;

需要注意的是，每一個Message都必須要有自己的Target即Handler實例！
源碼如下：

復制代碼 代碼如下:

public final Message obtainMessage(int what)
{
return Message.obtain(this, what);
}

public static Message obtain(Handler h, int what) {
Message m = obtain();
m.target = h;//可以看出message關聯了當前的Handler
m.what = what;
return m;
}

以上只是作了一點原理性的說明！

我們平時使用Handler主要是用來處理多線程的異步交互問題！
由于Android規定只有UI線程才能更新用戶界面和接受用戶的按鈕及觸摸事件！
那么就必須保證UI線程不可以被阻塞，從而耗時操作必須要開啟一個新的線程來處理！
那么問題就來了，等耗時操作結束以后，如何把最新的數據反饋給用戶呢？而我們目前工作Worker線程中，從而不可以進行UI更新。
那么怎么辦呢？必須要把最新的數據傳給UI線程能處理的地方！現在就派到Handler出場了！可Handler到底干了啥呢？簡要說明如下：
Activity所在的UI線程在創建的時候，就關聯了Looper和MessageQueue，那么我們又在UI線程里創建了自己的Handler，那么Handler是屬于UI線程的，從而它是可以和UI線程交互的！
UI線程的Looper一直在進行Loop操作MessageQueue讀取符合要求的Message給屬于它的target即 Handler來處理！所以啊，我們只要在Worker線程中將最新的數據放到Handler所關聯的Looper的MessageQueue中，然而 Looper一直在loop操作，一旦有符合要求的Message，就第一時間將Message交給該Message的target即Handler來處 理！所以啊，我們在創建Message的時候就應該指定它的target即Handler！
但我們也可以，new Message() — > mHandler.sendMessage(msg) ;這是特例！
如果我們通過obtainMessage()方法獲取Message對象，此時Handler就會自動設置Message的target。可以看源碼！

簡單一點說就是：
UI線程或Worker線程提供MessageQueue，Handler向其中填Message，Looper從其中讀Message，然后 交由Message自己的target即Handler來處理！！最終被從屬于UI線程的Handler的handlMessag(Message msg)方法被調用！！

這就是Android多線程異步處理最為核心的地方！！
有點羅嗦啊！！

*******************************************************************
在UI線程中創建Handler[一般繼承HandleMessage(Message msg)]

|
Looper可以屬于UI線程或Worker線程

|
從屬于Looper的MessgeQueue，Looper一直在loop()操作,在loop()中執行msg.target.dispatchMessage(msg);調用Handler的handleMessage(Message msg)

|
在 Worker線程中獲取Message，然后通過Handler傳入MessageQueue
*******************************************************************

—————–在創建一個Looper時，就創建了從屬于該Looper的MessageQueue
private Looper() {
mQueue = new MessageQueue();
mRun = true;
mThread = Thread.currentThread();
}

—-2—–View
post(Runnable action)
postDelay(Runnable action , long miliseconds)

—–3—–Activity
runOnUiThread(Runnable action)
該方法實現很簡單：
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
//如果當前線程不是UI線程
mHandler.post(action);
} else {
action.run();
}
}
其中：
mUiThread = Thread.currentThread() ;
mHandler = new Handler() 

—–4—–AsyncTask
Params,Progress,Result都是數據類型，
Params要處理的數據的類型
Progress處理進度的類型
Result處理后返回的結果

它是一個異步處理的簡單方法！
方法的執行順序：
1）
onPreExecute() –在UI線程中執行，作一些初始化操作

2）
doInBackground(Params… params) –在Worker線程中執行，進行耗時的后臺處理，在該方法中可以調用publishProgress(Progress progress) 進行進度處理

3）
onProgressUpdate(Progress progress) –在UI線程中執行，進行進度實時處理

4）onPostExecute(Result result) –在UI線程中執行， 在doInBackground(Params … params)返回后調用

5）
onCancelled() –在UI線程中執行，在AsyncTask實例調用cancle(true)方法后執行，作一些清理操作

幾點注意：
AsyncTask必須在UI線程中創建，
asyncTask.execute(Params… params) ;在UI線程中執行，且只能執行一次
要想再次調用execute(Params… params)，必須重新創建AsyncTask對象

后3種方法本質上都是利用Handler來實現的！