Android framework Handler\HandlerThread\Looper\Message\MessageQueue\

來源:互聯網
上載者:User

【Looper和Handler類分析】

就應用程式而言,Android系統中Java的應用程式和其他系統上相同,都是靠訊息驅動來工作的,他們大致的工作原理如下:

a.有一個訊息隊列,可以往這個訊息隊列中投遞訊息。

b.有一個訊息循環,不斷從訊息隊列中取出訊息,然後處理。

 

在Android系統中,這些工作主要由Looper和Handler來實現:

a.Looper類,用於封裝訊息循環,並且有一個訊息隊列。

b.Handler類,有點像輔助類,它封裝了訊息投遞、訊息處理等介面。

Looper類是其中的關鍵。

 

通過分析會發現,Looper的作用是:

a.封裝了一個訊息隊列。

b.Looper的prepare函數把這個Looper和調用prepare的線程(也就是最終的處理線程)綁定在一起了。

c.處理線程調用loop函數,處理來自該訊息隊列的訊息。

 

Looper、Message和Handler的關係

Looper、Message和Handler之間也存在曖昧關係:用兩句話就可以說清除:

a.Looper中有一個Message隊列,裡面存儲的是一個個待處理的Message。

b.Message中有一個Handler,這個Handler是用來處理Message的。

 

Handler把Message的target設為自己,是因為Handler除了封裝訊息添加等功能外還封裝了訊息處理的介面。

==================================Looper Used Sample ==============================

  * <p>This is a typical example of the implementation of a Looper thread,
  * using the separation of {@link #prepare} and {@link #loop} to create an
  * initial Handler to communicate with the Looper.
  *
  * <pre>
  *  class LooperThread extends Thread {
  *      public Handler mHandler;
  *      
  *      public void run() {
  *          Looper.prepare();
  *          
  *          mHandler = new Handler() {
  *              public void handleMessage(Message msg) {
  *                  // process incoming messages here
  *              }
  *          };
  *          
  *          Looper.loop();
  *      }
  *  }</pre>

================================== HandlerThread ==================================

    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

    /**
     * This method returns the Looper associated with this thread. If this thread not been started
     * or for any reason is isAlive() returns false, this method will return null. If this thread
     * has been started, this method will block until the looper has been initialized.  
     * @return The looper.
     */
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }

        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

 

================================== Resource Code ==================================

私人化的Looper:

 

    private Looper() {
mQueue = new MessageQueue();
mRun = true;
mThread = Thread.currentThread();
}

 

Looper的實例化:

     /** Initialize the current thread as a looper.
* This gives you a chance to create handlers that then reference
* this looper, before actually starting the loop. Be sure to call
* {@link #loop()} after calling this method, and end it by calling
* {@link #quit()}.
*/
public static final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
}

Looper循環:

    /** Returns the application's main looper, which lives in the main thread of the application.
*/
public synchronized static final Looper getMainLooper() {
return mMainLooper;
}
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static final void loop() {
Looper me = myLooper();
MessageQueue queue = me.mQueue;
while (true) {
Message msg = queue.next(); // might block
//if (!me.mRun) {
// break;
//}
if (msg != null) {
if (msg.target == null) {
// No target is a magic identifier for the quit message.
return;
}
if (me.mLogging!= null) me.mLogging.println(
">>>>> Dispatching to " + msg.target + " "
+ msg.callback + ": " + msg.what
);
msg.target.dispatchMessage(msg);
if (me.mLogging!= null) me.mLogging.println(
"<<<<< Finished to " + msg.target + " "
+ msg.callback);
msg.recycle();
}
}
}
/**
* Return the Looper object associated with the current thread. Returns
* null if the calling thread is not associated with a Looper.
*/
public static final Looper myLooper() {
return (Looper)sThreadLocal.get();
}
    public void quit() {
Message msg = Message.obtain();
// NOTE: By enqueueing directly into the message queue, the
// message is left with a null target. This is how we know it is
// a quit message.
mQueue.enqueueMessage(msg, 0);
}

 

通過下面的代碼,我們可以瞭解到,Handler的實例應在Looper實例之後。

    /**
* Default constructor associates this handler with the queue for the
* current thread.
*
* If there isn't one, this handler won't be able to receive messages.
*/
public Handler() {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> 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());
}
}

mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = null;
}

 

如果我們將Looper.prepare()放在Handler實例之後,將會出現什麼狀況呢???【可以用下面的代碼測試一下】

此段代碼摘自:http://blog.csdn.net/dengxiayehu
d、自己建立新的線程,然後在新線程中建立Looper,主線程調用子線程中的發訊息方法,將訊息發給子線程的訊息佇列。

Java代碼 收藏代碼

package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

public class MainActivity extends Activity {
private final static String TAG = "HandlerTest";

private final static int TASK_BEGIN = 1;
private final static int TASK_1 = 2;
private final static int TASK_2 = 3;
private final static int TASK_END = 4;

private Handler workHandler = null;

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +
"This is in main thread.");

LooperThread testThread = new LooperThread();
testThread.start();

// 注意,這裡需要等待一下,防止出現null 指標異常
while (null == workHandler) {
}

testThread.sendMessageTodoYourWork();
}

class LooperThread extends Thread {
@Override
public void run() {
Looper.prepare();

workHandler = new Handler() {
// 現在在每個case之後,你可以做任何耗時的操作了
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case TASK_BEGIN:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_BEGIN");
break;

case TASK_1:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_1");
break;

case TASK_2:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_2");
break;

case TASK_END:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_END");
Looper.myLooper().quit();
finish();
break;
}
super.handleMessage(msg);
}
};

Looper.loop();
}

public void sendMessageTodoYourWork() {
Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_START to handler.");
// 啟動任務(訊息只有標識,立即投遞)
workHandler.sendEmptyMessage(TASK_BEGIN);

Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_1 to handler.");
// 開始任務1(在workHandler的訊息佇列中擷取一個Message對象,避免重複構造)
Message msg1 = workHandler.obtainMessage(TASK_1);
msg1.obj = "This is task1";
workHandler.sendMessage(msg1);

Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_2 to handler.");
// 開啟任務2(和上面類似)
Message msg2 = Message.obtain();
msg2.arg1 = 10;
msg2.arg2 = 20;
msg2.what = TASK_2;
workHandler.sendMessage(msg2);

Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_END to handler.");
// 結束任務(空訊息體,延時2s投遞)
workHandler.sendEmptyMessageDelayed(TASK_END, 2000);
}
}
}

 

 

 

相關文章

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.