android Handler 单例运行 android的handler机制

转载

mob64ca14089531 2024-06-27 18:38:15

文章标签 android 线程通信源码 handler 文章分类 Android 移动开发

概述

Android系统的驱动机制是仿照Windows的消息驱动机制设计，在Android中线程之间的通信就靠消息来完成，这套机制由以下几个类来实现。

1.Message——消息

2.Handler———消息处理者

3.Looper——消息循环器

4.MessageQueue———消息队列

通过一个流程图来大致的描述这个机制

android Handler 单例运行 android的handler机制_android

我们可以看到，Handler首先将一个Message加入MessageQueue，MessageQueue由一个Looper维护，并通过一个无限循环从MessageQueue中取出Message，接着回调发送这个Message的Handler处理该Message。

从上述流程中我们可以推测出，如果需要让这个机制能够使线程之间正常通信，应该具有以下几个性质

1.每个线程应该只有一个Looper实例

2.每个Looper应该只维护一个MessageQueue

3.Handler实例应该与单一的MessageQueue绑定

4.Message类中有回调Handler的信息

5.Handler中有处理Message的方法

下面通过源码来分析这些性质

1.每个线程应该只有一个Looper实例

Looper的prepare()方法

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

在第五行将一个Looper放入了sThreadLocal对象中，而在第2~4行检查sThreadLocal中是否为null，若不为null则抛出异常，所以prepare()方法只能调用一次，这就保证了每个线程只有一个Looper实例。

2.每个Looper应该只维护一个MessageQueue

首先我们看一下Looper的构造方法

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

在第二行创建了一个MessageQueue实例

下面是loop方法()

public static void loop() {  
        final Looper me = myLooper();  
        if (me == null) {  
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");  
        }  
        final 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();  
  
        for (;;) {  
            Message msg = queue.next(); // might block  
            if (msg == null) {  
                // No message indicates that the message queue is quitting.  
                return;  
            }  
  
            // This must be in a local variable, in case a UI event sets the logger  
            Printer logging = me.mLogging;  
            if (logging != null) {  
                logging.println(">>>>> Dispatching to " + msg.target + " " +  
                        msg.callback + ": " + msg.what);  
            }  
  
            msg.target.dispatchMessage(msg);  
  
            if (logging != null) {  
                logging.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(TAG, "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();  
        }  
}

其中myLooper()

public static Looper myLooper() {
<span >	</span>return sThreadLocal.get();
}

在loop()中，从sThreadLocal中取出Looper，接着从Looper中取出MessageQueue，这两个在构造方法和prepare()方法中已经创建，接着在for(;;)这个无限循环内，不断的从MessageQueue中取出Message，并不断调用msg.target.dispatchMessage(msg)处理。

结合第一点，说明每个Looper只维护一个MessageQueue，并且我们可以得到Looper的作用

1.上述两点

2.不断从MessageQueue中取出Message，并交给target的dispatchMessage()方法处理，这个target是谁，将有助于分析下面的几点。

3.Handler实例应该与单一的MessageQueue绑定

使用Handler前我们都会先实例化一个Handler，先来看Handler的构造方法

public Handler() {  
        this(null, false);  
}  
public Handler(Callback callback, boolean async) {  
        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 = callback;  
        mAsynchronous = async;  
    }

在第十四行，通过myLooper()获取了当前线程的Looper实例，如果为null则抛出异常，所以Handler的实例化必须在Looper之后，在第19行获得了Looper中的MessageQueue，这样Handler就和MessageQueue绑定上了，并且一个Handler只绑定一个MessageQueue

4.Message类中有回调Handler的信息

看到这里，相信大家都想到，Looper回调Handler的关键就是message中的target到底是什么，首先让我们看一下我们常用的一些发送message的方法

<pre name="code" class="java">public final boolean sendMessage(Message msg)  
 {  
     return sendMessageDelayed(msg, 0);  
 }  
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {  
     Message msg = Message.obtain();  
     msg.what = what;  
     return sendMessageDelayed(msg, delayMillis);  
 }

<pre name="code" class="java">public final boolean sendMessageDelayed(Message msg, long delayMillis)  
   {  
       if (delayMillis < 0) {  
           delayMillis = 0;  
       }  
       return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);  
   }

接着是

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {  
       MessageQueue queue = mQueue;  
       if (queue == null) {  
           RuntimeException e = new RuntimeException(  
                   this + " sendMessageAtTime() called with no mQueue");  
           Log.w("Looper", e.getMessage(), e);  
           return false;  
       }  
       return enqueueMessage(queue, msg, uptimeMillis);  
   }

最后

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {  
       msg.target = this;  
       if (mAsynchronous) {  
           msg.setAsynchronous(true);  
       }  
       return queue.enqueueMessage(msg, uptimeMillis);  
   }

第二行，将this赋给了msg的target，在第二点中我们已经看到，在loop()中，将msg交给了target的dispatchMessage()方法处理，所以Message中包含了回调Handler的信息。

第6行，调用queue的enqueueMessage()，最终将message放入MessageQueue

5.Handler中有处理Message的方法

最后我们看一下dispatchMessage这个方法()

public void dispatchMessage(Message msg) {  
        if (msg.callback != null) {  
            handleCallback(msg);  
        } else {  
            if (mCallback != null) {  
                if (mCallback.handleMessage(msg)) {  
                    return;  
                }  
            }  
            handleMessage(msg);  
        }  
    }

接着是handleMessage()

/** 
   * Subclasses must implement this to receive messages. 
   */  
  public void handleMessage(Message msg) {  
  }

handleMessage是一个空方法，因为这个是我们必须重写的方法，根据具体需要，处理message。

总结

至此，我们通过以上几个性质，分析了handler机制的整个工作流程，这里做一下简单的总结

1.首先Looper.prepare()在线程中保存了一个Looper对象，并且Looper对象实例化了一个MessageQueue，因为，prepare()只能调用一次，所以每个线程只有一个Looper并且只维护一个MessageQueue。

2.Looper.loop()方法，开启一个无限循环从MessageQueue中取出Message，并回调msg.target.dispaMessage(msg)方法处理该Message

3.实例化Handler时，在构造方法中，Handler会得到该线程下的Looper进而与MessageQueue绑定，并且在构造Handler时我们会重写handleMessage方法，用以处理Message

4.调用Handler的sendMessage方法，会将Handler自身赋给Msg的target，并在loop()中被用以回调。

每个UI线程即Activity在初始化的时候会自动调用Looper.prepare()以及loop()所以UI线程不需要手动调用。

Handler.post()

post()其实与上述方法并无区别，我们看一下源码

public final boolean post(Runnable r)  
   {  
      return  sendMessageDelayed(getPostMessage(r), 0);  
   }  

private static Message getPostMessage(Runnable r) {  
      Message m = Message.obtain();  
      m.callback = r;  
      return m;  
  }

将我们的Runnable赋给了Message的callback，在第五点中，callback不为空，执行callback回调，回到我们重写的Runnable中做具体处理。

以上就是我对Handler的一点理解，本文大量参考了其他博文，主要用于我对知识点的记忆和整理。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。