android handler机制源码解析【异步回调】

流程总结

  1. Looper.prepare():本线程中保存一个Looper实例,然后该实例中保存一个MessageQueue对象;因为Looper.prepare()在一个线程中只能调用一次,所以MessageQueue在一个线程中只会存在一个。
  2. Looper.loop():轮询MessageQueue,回调msg.target.dispatchMessage(msg)方法。
  3. Handler构造方法:得到当前线程中保存的Looper实例,进而与Looper实例中的MessageQueue想关联。
  4. Handler的sendMessage():会给msg的target赋值为handler自身,然后加入MessageQueue中。
  5. 重写handleMessage():是msg.target.dispatchMessage(msg)最终调用的方法。

Tip:在Activity的启动代码中,已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。创建handler就不用显示的调用Looper.prepare()和Looper.loop()

观察者模式

Looper

创建一个MessageQueue,轮询MessageQueue

  • 构造方法
    • private Looper(boolean quitAllowed) {  
              mQueue = new MessageQueue(quitAllowed);  
              mRun = true;  
              mThread = Thread.currentThread();  
      }

    • 创建messageQueue
  • 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));  
      } 
       
      

    • 不能被调用2次,有且只有一个
  • loop()
    • looper方法必须在prepare方法之后运行
    • 轮询,无 -> 阻塞,有 -> msg.target.dispatchMessage(msg);
  • 作用
    • 绑定当前线程,有且只有一个looper实例和MessageQueue,轮询并通知

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;  
    }  


  • mLooper = Looper.myLooper();  获取looper
  • mQueue = mLooper.mQueue;获取messagequeue

public final boolean sendMessage(Message msg)  
 {  
     return sendMessageDelayed(msg, 0);  
 } 

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

  • msg.target = this;  => msg.target.dispatchMessage(msg); handler发出的消息,最终会保存到消息队列中去

Message

dispathMessage

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

因为消息的最终回调是由我们控制的,我们在创建handler的时候都是复写handleMessage方法,然后根据msg.what进行消息处理

private Handler mHandler = new Handler()  
    {  
        public void handleMessage(android.os.Message msg)  
        {  
            switch (msg.what)  
            {  
            case value:  
                  
                break;  
  
            default:  
                break;  
            }  
        };  
    };  


  • public int what:变量,用于定义此Message属于何种操作
  • public Object obj:变量,用于定义此Message传递的信息数据,通过它传递信息
  • public int arg1:变量,传递一些整型数据时使用
  • public int arg2:变量,传递一些整型数据时使用
  • public Handler getTarget():普通方法,取得操作此消息的Handler对象。

完成调度信息

  •  {@link #post}, {@link #postAtTime(Runnable, long)},
  •  {@link #postDelayed}, {@link #sendEmptyMessage},
  •  {@link #sendMessage}, {@link #sendMessageAtTime}, and
  •  {@link #sendMessageDelayed} methods.  The <em>post</em> versions allow

Handler post

mHandler.post(new Runnable()  
        {  
            @Override  
            public void run()  
            {  
                Log.e("TAG", Thread.currentThread().getName());  
                mTxt.setText("yoxi");  
            }  
        });  

Runnable并没有创建什么线程,而是发送了一条消息
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;  
  }  
在getPostMessage中,得到了一个Message对象,然后将我们创建的Runable对象作为callback属性,赋值给了此message.

注:

  • 产生一个Message对象,可以new  ,也可以使用Message.obtain()
  • Message内部维护了一个Message池用于Message的复用,使用Message.obtain()方法避免使用new 重新分配内存。
  • 如果你的message只需要携带简单的int信息,请优先使用Message.arg1和Message.arg2来传递信息,这比用Bundle更省内存
  • 擅用message.what来标识信息,以便用不同方式处理message

如果不为null,则执行callback回调,也就是我们的Runnable对象。


问题

1,使用Handler 是异步的,它会建立新的线程么? 不会
2,Handler 是在主线程内么? 一般都会在主线程内,但也可以在子线程中创建Handler
3,Handler 的 post 和 sendMessage 方法,使用的是一个队列不安是两个? 一个
4,子线程中建立一个 handler, 然后sendMessage 会怎么样? 会崩溃
5,子线程建立 handler ,构造的时候舒心入主线程的 Looper ? yes




你可能感兴趣的:(源码,android,handler)