Looper Handler Message

最新推荐文章于 2024-05-12 12:07:57 发布

pediyasm

最新推荐文章于 2024-05-12 12:07:57 发布

阅读量676

点赞数

分类专栏： android 文章标签： thread null class token string

本文链接：https://blog.csdn.net/pediyasm/article/details/7179100

版权

android 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

本文深入探讨了Looper在Java中的实现原理及作用，着重解释了如何通过Looper和Handler来创建并管理消息循环，包括Looper的prepare、loop方法，以及Handler的sendMessageAtTime方法的具体使用场景和细节。

摘要由CSDN通过智能技术生成

Looper.java 分析

Class used to run a message loop for a thread.
Threads by default do not have a message loop associated with them; to create one, call prepare in the thread that is to run the loop, and then loop to have it process messages until the loop is stopped.

Most interaction with a message loop is through the Handler class.

This is a typical example of the implementation of a Looper thread, using the separation of prepare and loop to create an initial Handler to communicate with the Looper.

class LooperThread extends Thread {
      public Handler mHandler;
      
      public void run() {
		  //Initialize the current thread as a looper
		  // 创建消息队列
          Looper.prepare();
          
	  mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };
          
		  // 消息的处理 msg.target.dispatchMessage(msg);
          Looper.loop();
      }
  }

public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    {
        boolean sent = false;
        // Looper.prepare()创建的队列
        MessageQueue queue = mQueue;
        if (queue != null) {
            // 把消息目标设成自己，在Looper.loop()里进行消息处理；
            msg.target = this;
            sent = queue.enqueueMessage(msg, uptimeMillis);
        }
        else {
            RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
        }
        return sent;
    }

public static final void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }

 public static final void loop() {
        Looper me = myLooper();
        MessageQueue queue = me.mQueue;
        
        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
        
        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);
                
                // Make sure that during the course of dispatching the
                // identity of the thread wasn't corrupted.
                final long 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);
                }
                
                msg.recycle();
            }
        }
    }

Looper 和 Handler 的同步关系

public class HandlerThread extends Thread {
	private Looper mLooper;

	HandlerThread(String name) {
		super(name);
	}
	
	protected void onLooperPrepared() {}

	public void run() {
		Looper.prepare();
		synchronized(this) {
			mLooper = Looper.myLooper();
			notifyAll();
		}
		onLooperPrepared();
		Looper.loop();
	}

	/**
	*	If this thread has been started, this method will block until the looper has been initialied.
	*/
	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;
	}

	public boolean quit() [
		Looper looper = getLooper();
		if (looper != null) {
			looper.quit();
			return true;
		}
		return false;
	}
}