Adamin90

Handler允许发送和处理与线程的MessageQueue相关联Message和Runnable对象。每一个Handler实例都与一个单独的线程和该线程的消息队列相关联。当创建Handler的时候，它被它创建的线程绑定。它把Message或Runnable对象传递到消息队列，出队的时候执行它们。Handler有两个主要用处：1.调度消息和Runnable在未来的某个时间点执行。2.入队一个操作并在不同的线程上执行。 调度消息通过post，postAtTime(Runnable,long),postDelayed,sendEmptyMessage,sendMessage,sendMessageAtTime,sendMessageDelayed方法完成。post版本允许入队Runnable对象，sendMessage版本允许入队Message对象，Message对象包含的数据会被Handler的handleMessage方法处理（需要自己实现Handler的子类）。 post或send的时候可以允许item在消息队列准备好的时候立即处理，或者定义一个时间延迟或确切的时间处理。 当一个应用的进程创建完，它的主线程专注运行一个消息队列,负责管理高级别的应用对象（Activity，BroadcastReceiver等）和他们创建的window，我们可以创建自己的子线程，并通过Handler和主线程通信。这样是通过在子线程里调用post或sendMessage方法完成。然后Runnable或Message将在Handler的消息队列里调度，在合适的时候处理。 构造函数 Handler总共有7个构造函数 #无参构造函数，内部调用6，callback传null，async传false 1. public Handler() {         this(null, false);     } #设置消息处理回调，内部调用6，async传false 2. public Handler(@Nullable Callback callback) {         this(callback, false);     }   #设置Looper，这样就不用调用Looper.prepare方法，内部调用7 3. public Handler(@NonNull Looper looper) {         this(looper, null, false);     }     #设置Looper和回调，内部调用7 4. public Handler(@NonNull Looper looper, @Nullable Callback callback) {         this(looper, callback, false);     }     #设置消息是否异步，内部调用6 5. public Handler(boolean async) {         this(null, async);     }     #设置回调和是否异步，内部检测looper是否为空，所以所有内部调用这个方法的构造函数都需要先调用Looper.prepare方法初始化Looper和MessageQueue 6. public Handler(@Nullable 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 " + Thread.currentThread()                         + " that has not called Looper.prepare()");         }         mQueue = mLooper.mQueue;         mCallback = callback;         mAsynchronous = async;     }  #设置Looper，回调，是否异步    7. public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {         mLooper = looper;         mQueue = looper.mQueue;         mCallback = callback;         mAsynchronous = async;     } Handler总共有7个构造函数，分别应用在不同场景下，可以设置消息是否异步，设置Looper，回调。 消息处理 … Read more

Looper在Handler机制中主要在线程中进行消息循环。线程中默认没有关联的Looper。在线程调用Looper.prepare方法创建关联的looper，调用Looper.loop方法处理消息，直到loop停止。大部分与消息循环的交互是通过Handler类。官方文档给出了一个简单实例实现了一个Looper线程，使用prepare和loop常见一个Handler与Looper通信。 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();          }      } Looper.prepare 通过ThreadLocal存储当前线程的Looper实例 #线程本地变量存储Looper实例 static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); final MessageQueue mQueue;#关联的消息队列 final Thread mThread; #创建Looper的线程  public static void prepare() {         prepare(true);     }     private static void prepare(boolean quitAllowed) {         if (sThreadLocal.get() != null) {          #prepare只允许调用一次              throw new RuntimeException("Only one Looper may be created per thread");         }         sThreadLocal.set(new Looper(quitAllowed)); #新实例创建，存入本地线程变量副本     }       private Looper(boolean quitAllowed) {         mQueue = new MessageQueue(quitAllowed); #消息队列实例化         mThread = Thread.currentThread(); #创建的线程     } preprare参数quitAllowed代表跟Looper关联的MessageQueue是否允许退出，默认允许，Looper实例化的同时，也实例化了关联的MessageQueue，给线程变量mThread赋值，主线程的MessageQueue是不允许退出的，在ActivityThread的main方法中调用Looper.prepareMainLooper方法，内部prepare传参为false，表示不允许退出。 消息循环，Looper.loop public static @Nullable Looper myLooper() {         return sThreadLocal.get();     } public static void loop() {         final Looper me = myLooper();         if (me == null) {             #没有调用prepare方法，线程本地变量获取不到looper实例，直接抛出异常              throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");         }         final MessageQueue queue = me.mQueue;        ….         boolean slowDeliveryDetected = false;         for (;;) {            #从MessageQueue取消息，             Message msg = queue.next(); // might block             if (msg == null) {                 // 没有消息，消息队列正在退出 … Read more

MessageQueue是一个低级别的类，持有一个由Looper传递的消息列表。Message不是直接添加到MessageQueue里的。而是由跟Looper关联的Handler对象添加的。 可以通过Looper.myQueue()方法提取跟当前线程关联的MessageQueue。 MessageQueue的构造函数：  MessageQueue(boolean quitAllowed) {         mQuitAllowed = quitAllowed;         mPtr = nativeInit();     } mQuitAllowed表示是否允许退出，mPtr是navite函数的返回值，nativeInit位于C++层/frameworks/base/core/jni/android_os_MessageQueue.cpp文件内： static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {     NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();     if (!nativeMessageQueue) {         jniThrowRuntimeException(env, "Unable to allocate native queue");         return 0;     }    nativeMessageQueue->incStrong(env);     return reinterpret_cast<jlong>(nativeMessageQueue); }     首先实例化NaviteMessageQue，然后强制转换成long类型返回，那么mPtr就是一个指向NativeMessageQueue的指针，MessageQueue初始化的时候由nativeInit赋值，销毁的时候在finalizelize方法里调用dispose方法置零。  private void dispose() {         if (mPtr != 0) {             nativeDestroy(mPtr);             mPtr = 0;         }     }     回过头看构造函数，形参quitAllowed表示是否允许退出消息队列，主线程这个参数会传递成false，表示不允许退出，在ActivityThread的main方法里调用Looper.prepareMainLooper(),最终调用Lopper的构造函数，在构造函数里初始化MessageQueue，quitAllowed传参false。  private Looper(boolean quitAllowed) {         mQueue = new MessageQueue(quitAllowed);         mThread = Thread.currentThread();     } 我们平时调用Looper.prepare()，方法的时候，构造的MessageQueue默认是允许退出的。 消息入队 MessageQueue的消息入队方法是enqueueMessage,改方法在Handler里的enqueueMessage方法里调用。  boolean enqueueMessage(Message msg, long when) {         #判断入队消息对象的handler是否存在，不存在抛出异常         if (msg.target == null) {             throw new IllegalArgumentException("Message must have a target.");         }         #判断消息是否正在使用（消息队列里或回收池里），使用的话抛出异常         if (msg.isInUse()) {             throw new IllegalStateException(msg + " This message is already in use.");         }         synchronized (this) {             if (mQuitting) { #正在退出，回首消息并返回false                 IllegalStateException e = new IllegalStateException(                         msg.target + " sending message to a Handler on a dead thread");                 Log.w(TAG, e.getMessage(), e);                 msg.recycle();                 return false;             }          #消息标记成使用中状态             msg.markInUse();             msg.when = when;             Message p = mMessages;             boolean needWake;             #当前队列头部消息是空，或者when是0（代表立即执行），或执行的时间小于当前队首执行的时间，则把该消息放到队首 … Read more

    Message翻译过来是消息，顾名思义，在Android中它定义了一个消息体，消息包含了描述和任意的数据对象，可以被发送给Handler。Message对象包含了两个int类型的额外字段，也包含一个object类型的额外字段，可以在多种情况下不分配。 尽管Message的构造器是public类型的，但最好的获取Message对象的方法是调用Message.obtain()方法或者Handler.obtainMessage()方法，这将会从对象回收池中拉取对象。 享元模式（FlyWeight） 享元模式是23种Gof设计模式结构化模式的一种，它在处理大量具有简单重复元素，单独存储会使用大量内存的时候非常有用，通常做法是把共享的数据存储在外部的数据结构里面，使用的时候把他们传递给对象。 Handler.obtainMessage方法内部也是调用的Message.obtain,所以只看后者：  public static final Object sPoolSync = new Object();     private static Message sPool;     private static int sPoolSize = 0; #当前消息池的大小     ….     ….     private static final int MAX_POOL_SIZE = 50;  #缓存消息池最大容量   public static Message obtain() {         synchronized (sPoolSync) {             if (sPool != null) {                 Message m = sPool;                 sPool = m.next;                 m.next = null;                 m.flags = 0; // clear in-use flag                 sPoolSize–;                 return m;             }         }         return new Message();     }     sPool如果是空，则new一个新的Message,非空的话从缓存池获取对象，并清空获取到的Message对象的flags,消息池当前大小减1。此外Message还有几个重载的obtain方法，分别对应不同场景对Message对象设置不同的属性，本质上都是从缓存池拿对象。 消息回收 Message回收共有两个方法，回收就是把Message对象放在全局的回收池，两个方法分别是： recycleUnchecked() /**      * Recycles a Message that may be in-use.回收一个可能在使用的消息      * Used internally by the MessageQueue and Looper when disposing of queued Messages.处理完队列消息时在MessageQueue和Looper内部使用       */     @UnsupportedAppUsage     void recycleUnchecked() {         // Mark the message as in use while it remains in the recycled object pool.         // Clear out all other details.清空其他的详细信息         flags = FLAG_IN_USE;         what = 0;         arg1 = 0;         arg2 = 0;         obj = null;         replyTo = null;         sendingUid = UID_NONE;         workSourceUid = UID_NONE;         when = 0;         target = null;         callback = null;         data = null;             synchronized (sPoolSync) {             if (sPoolSize < MAX_POOL_SIZE) {              #缓存池对象小于50，当前缓存池后移，当前对象放在链表首部，缓存池大小加一                 next = sPool;                 sPool = this;                 sPoolSize++; … Read more