編輯：關於Android編程
Looper的字面意思是“循環者”，它被設計用來使一個普通線程變成Looper線程。所謂Looper線程就是循環工作的線程。在程序開發中（尤其是GUI開發中），經常會需要一個線程不斷循環，一旦有新任務則執行，執行完繼續等待下一個任務，這就是Looper線程。使用Looper類創建Looper線程很簡單，代碼如下：
publicclass LooperThread extends Thread {
@Override
publicvoid run() {
// 將當前線程初始化為Looper線程
Looper.prepare();
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 0:
break;
default:
break;
}
}
// 開始循環處理消息隊列
Looper.loop();
}
}
通過上面兩行核心代碼，普通線程就升級為Looper線程了！！！看看這兩行代碼各自做了什麼。
1)Looper.prepare()
通過上圖可以看到，現在你的線程中有一個Looper對象，它的內部維護了一個消息隊列MQ。注意，一個Thread只能有一個Looper對象，為什麼呢？咱們來看源碼。
看源碼。
// 每個線程中的Looper對象其實是一個ThreadLocal，即線程本地存儲(TLS)對象
privatestaticfinal ThreadLocal sThreadLocal =new ThreadLocal();
// Looper內的消息隊列
final MessageQueue mQueue;
// 當前線程
Thread mThread;
// 。。。其他屬性
// 每個Looper對象中有它的消息隊列，和它所屬的線程
private Looper(boolean quitAllowed) {
mQueue =new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
// 我們調用該方法會在調用線程的TLS中創建Looper對象
publicstaticfinalvoid prepare() {
if (sThreadLocal.get() !=null) {
// 試圖在有Looper的線程中再次創建Looper將拋出異常
thrownew RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
// 其他方法
}
通過源碼，prepare()背後的工作方式一目了然，其核心就是將looper對象定義為ThreadLocal。
2）Looper.loop()
調用loop方法後，Looper線程就開始真正工作了，它不斷從自己的MQ中取出隊頭的消息(也叫任務)執行。其源碼分析如下：
publicstaticfinalvoid loop() {
Looper me = myLooper(); //得到當前線程Looper
MessageQueue queue = me.mQueue; //得到當前looper的MQ
Binder.clearCallingIdentity();
finallong ident = Binder.clearCallingIdentity();
// 開始循環
for(;;) {
Message msg = queue.next(); // 取出message
if (msg !=null) {
if (msg.target ==null) {
// message沒有target為結束信號，退出循環
return;
}
// 日志。。。
if (me.mLogging!=null) me.mLogging.println(
">>>>> Dispatching to "+ msg.target +""
+ msg.callback +": "+ msg.what
);
// 非常重要！將真正的處理工作交給message的target，即後面要講的handler
msg.target.dispatchMessage(msg);
// 還是日志。。。
if (me.mLogging!=null) me.mLogging.println(
"<<<<< Finished to "+ msg.target +""
+ msg.callback);
finallong newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf("Looper", "Thread identity changed from 0x"
+ Long.toHexString(ident) +" to 0x"
+ Long.toHexString(newIdent) +" while dispatching to "
+ msg.target.getClass().getName() +""
+ msg.callback +" what="+ msg.what);
}
// 回收message資源
msg.recycle();
}
}
}
除了prepare()和loop()方法，Looper類還提供了一些有用的方法，比如
Looper.myLooper()得到當前線程looper對象：
publicstaticfinal Looper myLooper() {
// 在任意線程調用Looper.myLooper()返回的都是那個線程的looper
return (Looper)sThreadLocal.get();
}
getThread()得到looper對象所屬線程：
public Thread getThread() {
return mThread;
}
quit()方法結束looper循環
publicvoid quit() {
// 創建一個空的message，它的target為NULL，表示結束循環消息
Message msg = Message.obtain();
// 發出消息
mQueue.enqueueMessage(msg, 0);
}
到此為止，你應該對Looper有了基本的了解，總結幾點：
1.每個線程有且最多只能有一個Looper對象，它是一個ThreadLocal
2.Looper內部有一個消息隊列，loop()方法調用後線程開始不斷從隊列中取出消息執行
3.Looper使一個線程變成Looper線程。
那麼，我們如何往MQ上添加消息呢？下面有請Handler！
Handler對象可以發送和處理與一個線程的消息隊列相關聯的Message和Runnable對象。每一個Handler的實例都與一個獨立的線程及其消息隊列相關聯。
當一個新的Handler對象被創建，它就會被綁定到創建它的線程的消息隊列之上，從這一刻開始，
這個Handler對象便會將Message和Runnable對象發送給它所綁定的消息隊列，並且在這些對象離開隊列後，處理他們。
Android中，Handler有以下兩個主要的用途：
?將Message或Runnable對象發送給其他線程。可以使用post(Runnable)、postAtTime(Runnable, long)、postDelayed(Runnable, long)、
sendEmptyMessage(int)、sendMessage(Message)、sendMessageAtTime(Message, long)和sendMessageDelayed(Message, long)等
方法發送Message或Runnable對象。可以看到，post()系列的方法可以發送Runnable對象，而sendMessage()系列的方法可以發送Message。
?處理來自其他線程的Message，安排來自其他線程的Runnable對象得以執行，可以使用handleMessage(Message)方法處理接收到的Message。
當一個Android應用程序被創建後，在它的UI線程中就會運行一個消息隊列，該隊列會關注對頂層應用程序組件的管理，比如Activity、Service和BroadcastReceiver，以及它們所創建的所有窗口。開發者可以創建自己的線程，並通過Handler對象的post()系列方法和sendMessage()系列方法與UI線程進行通信，被這些方法發送的Message或Runnable對象會在未來合適的時間被處理和執行。
什麼是handler？handler扮演了往MQ上添加消息和處理消息的角色（只處理由自己發出的消息），即通知MQ它要執行一個任務(sendMessage)，並在loop到自己的時候執行該任務(handleMessage)，整個過程是異步的。handler創建時會關聯一個looper，默認的構造方法將關聯當前線程的looper。默認的構造方法：
publicclass handler {
final MessageQueue mQueue; // 關聯的MQ
final Looper mLooper; // 關聯的looper
final Callback mCallback;
// 其他屬性
public Handler() {
if (FIND_POTENTIAL_LEAKS) {
final Class klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) ==0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: "+
klass.getCanonicalName());
}
}
// 默認將關聯當前線程的looper
mLooper = Looper.myLooper();
// looper不能為空，即該默認的構造方法只能在looper線程中使用
if (mLooper ==null) {
thrownew RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
// 重要！！！直接把關聯looper的MQ作為自己的MQ，因此它的消息將發送到關聯looper的MQ上
mQueue = mLooper.mQueue;
mCallback =null;
}
// 其他方法
}
下面我們就可以為之前的LooperThread類加入Handler：
publicclass LooperThread extends Thread {
private Handler handler1;
private Handler handler2;
@Override
publicvoid run() {
// 將當前線程初始化為Looper線程
Looper.prepare();
// 實例化兩個handler
handler1 =new Handler();
handler2 =new Handler();
// 開始循環處理消息隊列
Looper.loop();
}
}
可以看到，一個線程可以有多個Handler，但是只能有一個Looper！
Handler發送消息
有了handler之後，我們就可以使用post(Runnable),postAtTime(Runnable, long),postDelayed(Runnable, long),sendEmptyMessage(int),sendMessage(Message),sendMessageAtTime(Message, long)和sendMessageDelayed(Message, long)這些方法向MQ上發送消息了。光看這些API你可能會覺得handler能發兩種消息，一種是Runnable對象，一種是message對象，這是直觀的理解，但其實post發出的Runnable對象最後都被封裝成message對象了，見源碼：
// 此方法用於向關聯的MQ上發送Runnable對象，它的run方法將在handler關聯的looper線程中執行
publicfinalboolean post(Runnable r)
{
// 注意getPostMessage(r)將runnable封裝成message
return sendMessageDelayed(getPostMessage(r), 0);
}
privatefinal Message getPostMessage(Runnable r) {
Message m = Message.obtain(); //得到空的message
m.callback = r; //將runnable設為message的callback，
return m;
}
publicboolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent =false;
MessageQueue queue = mQueue;
if (queue !=null) {
msg.target =this; // message的target必須設為該handler！
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e =new RuntimeException(
this+" sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}
總之通過handler發出的message有如下特點：
1.message.target為該handler對象，這確保了looper執行到該message時能找到處理它的handler，即loop()方法中的關鍵代碼
msg.target.dispatchMessage(msg);
2.post發出的message，其callback為Runnable對象
Handler處理消息
說完了消息的發送，再來看下handler如何處理消息。消息的處理是通過核心方法dispatchMessage(Messagemsg)與鉤子方法handleMessage(Messagemsg)完成的，見源碼
// 處理消息，該方法由looper調用
publicvoid dispatchMessage(Message msg) {
if (msg.callback !=null) {
// 如果message設置了callback，即runnable消息，處理callback！
handleCallback(msg);
} else {
// 如果handler本身設置了callback，則執行callback
if (mCallback !=null) {
/* 這種方法允許讓activity等來實現Handler.Callback接口，避免了自己編寫handler重寫handleMessage方法。 */
if (mCallback.handleMessage(msg)) {
return;
}
}
// 如果message沒有callback，則調用handler的鉤子方法handleMessage
handleMessage(msg);
}
}
// 處理runnable消息
privatefinalvoid handleCallback(Message message) {
message.callback.run(); //直接調用run方法！
}
// 由子類實現的鉤子方法
publicvoid handleMessage(Message msg) {
}
可以看到，除了handleMessage(Messagemsg)和Runnable對象的run方法由開發者實現外（實現具體邏輯），handler的內部工作機制對開發者是透明的。這正是handler API設計的精妙之處！
Handler的用處
handler被描述為“異步處理大師”，這歸功於Handler擁有下面兩個重要的特點：
1.handler可以在任意線程發送消息，這些消息會被添加到關聯的MQ上。
2.handler是在它關聯的looper線程中處理消息的。
這就解決了android最經典的不能在其他非主線程中更新UI的問題。android的主線程也是一個looper線程(looper在android中運用很廣)，我們在其中創建的handler默認將關聯主線程MQ。因此，利用handler的一個solution就是在activity中創建handler並將其引用傳遞給worker thread，worker thread執行完任務後使用handler發送消息通知activity更新UI。(過程如圖)
下面給出sample代碼，僅供參考：
publicclass TestDriverActivity extends Activity {
private TextView textview;
@Override
protectedvoid onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
textview = (TextView) findViewById(R.id.textview);
// 創建並啟動工作線程
Thread workerThread =new Thread(new SampleTask(new MyHandler()));
workerThread.start();
}
publicvoid appendText(String msg) {
textview.setText(textview.getText() +"\n"+ msg);
}
class MyHandler extends Handler {
@Override
publicvoid handleMessage(Message msg) {
String result = msg.getData().getString("message");
// 更新UI
appendText(result);
}
}
}
publicclass SampleTask implements Runnable {
privatestaticfinal String TAG = SampleTask.class.getSimpleName();
Handler handler;
public SampleTask(Handler handler) {
super();
this.handler = handler;
}
@Override
publicvoid run() {
try { // 模擬執行某項任務，下載等
Thread.sleep(5000);
// 任務完成後通知activity更新UI
Message msg = prepareMessage("task completed!");
// message將被添加到主線程的MQ中
handler.sendMessage(msg);
} catch (InterruptedException e) {
Log.d(TAG, "interrupted!");
}
}
private Message prepareMessage(String str) {
Message result = handler.obtainMessage();
Bundle data =new Bundle();
data.putString("message", str);
result.setData(data);
return result;
}
}
當然，handler能做的遠遠不僅如此，由於它能post Runnable對象，它還能與Looper配合實現經典的Pipeline Thread(流水線線程)模式。
三、封裝任務 MessageMessage是線程之間通信的信息載體，它包含一些特定的描述信息和任意的附加數據。Message對象具有getData()和setData()方法，它們分別可以獲取和添加用Bundle對象封裝的數據，這些數據就是線程之間相互傳遞的數據。消息對象中還包含兩個int型的字段和一個Object型的字段，當通信的數據量少時，可以使用這三個字段存放數據
在整個消息處理機制中，message又叫task，封裝了任務攜帶的信息和處理該任務的handler。message的用法比較簡單，使用Message需要注意4點：
1、Message雖然也可以通過new來獲取，但是通常使用Message.obtain()或Handler.obtainMessage()方法來從消息池中獲得空消息對象，以節省資源；2、如果一個Message只需要攜帶簡單的int型數據，應優先使用arg1和arg2屬性來傳遞數據，這樣比Bundle節省內存；3、盡可能使用Message.what來標識信息，以便用不同的方式處理Message。4、如果需要從工作線程返回很多數據信息，可以借助Bundle對象將這些數據集中到一起，然後存放到obj屬性中，再返回到主線程。MessageQueue
* 顧名思義，消息隊列（MessageQueue）就是一個由Message組成的隊列，既然是隊列，就是先進先出的，即先入隊的Message會優先被取出。
*消息隊列是一個偏底層的類，它包含的Message由Looper對象分發出去。Message並不是直接被添加進消息隊列的，
*而是通過與Looper相關的MessageQueue.IdleHandler對象添加的。可以使用Looper.myQueue()方法取回當前線程的消息隊列
收藏的Android非常好用的組件或者框架。
收藏的Android非常好用的組件或者框架。 android框架 先說兩個網站： http://www.androidviews.net/ 很好的國外開源代碼站，就是訪
Android通過startService實現文件批量下載
關於startService的基本使用概述及其生命周期可參見《Android中startService基本使用方法概述》。本文通過批量下載文件的簡單示例，演示startS
安卓自定義控件之可變字符串大小顏色控件
“` import android.content.Context;import android.content.res.TypedArray;im
Android webview和js互相調用實現方法
Android-webview和js互相調用Android 和 H5 都是移動開發應用的非常廣泛。市面上很多App都是使用Android開發的，但使用Android來開發
