Android Handler学习笔记

已经习惯了挖坑不填，继续任性一下，周一到周五继续挖坑，每周六周日负责填坑。

1.从Android UI线程谈起

出于性能考虑，Android 中的UI操作并不是线程安全的，所以Android中规定只能在主线程中修改Activity中的UI组件，故主线程又称UI线程。Android程序启动时会同时启动UI线程，该线程负责处理UI相关事件，并且进行事件分发。

• 不是线程安全可以理解为两个人同时独立的在一张纸上画画，最后画出来的就是错乱的。实现线程安全可以通过加锁进行数据保护，以后有机会写C++相关博客再介绍多线程问题。

在某些情况下我们需要让新启动的线程周期性更新UI（比如游戏动画中），所以要找一个方式在子线程中发送消息，在主线程接受消息，配合起来更新UI，这时我们就需要Handler了。

2.Handler是个什么鬼

参考资料：

疯狂Android讲义第三章

Handler运行机制

Handler的主要作用有两个：1）在新线程发送消息，2）在主线程获取和处理消息

先用了再说：

/*
*主线程中使用Handler
*/
private static final String TAG = "HandlerActivity";
private Handler mHandler;
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_handler_test);
  //在主线程中创建Hander对象
    mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
          //接受消息对象并处理
            super.handleMessage(msg);
            Log.e(TAG,"------------> msg.what = " + msg.what);
        }
    };
    new Thread(new Runnable() {
      @Override
      public void run() {

        SystemClock.sleep(2000);
       //在子线程中使用Handler对象发送消息
        mHandler.sendEmptyMessage(0);
      }
    }).start();
}

感觉很好用，说起来就是Android不允许子线程访问UI组件，所以我们要在新线程中发送消息，让系统更新UI组件。在new出来的Handler对象中重写了handleMessage()，当通过新线程发送消息是，该方法自动被回调。

接下来总结一下Handler中的消息发送和处理方法：

算了，懒得总结，直接看官方文档

常用的有这些：

发送消息：sendMessage(),sendEmptyMessage(),sendMessageDelayed(),sendEmptyMessageDelayed()

接受处理消息：handleMessage,obtainMessage()等

3.可以在子线程创建Handler吗

Handler系列之创建子线程Handler

子线程中可以使用Handler吗？

/*
*子线程中使用Handler
*/
private static final String TAG = "TestHandlerActivity";
//主线程中的handler
private Handler mHandler;
//子线程中的handler
private Handler mHandlerThread = null;

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_handler_test);
//创建handler对象
  mHandler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
      super.handleMessage(msg);
      //获得刚才发送的Message对象，然后在这里进行UI操作
      Log.e(TAG,"------------> msg.what = " + msg.what);
    }
  };

  new Thread(new Runnable() {
    @Override
    public void run() {

      SystemClock.sleep(2000);
      //通过Handler发送一个消息切换回主线程（mHandler所在的线程）
      mHandler.sendEmptyMessage(0);

      /*
      //调用Looper.prepare（）方法
      Looper.prepare();
      */

      //在子线程中创建Handler
      mHandlerThread = new Handler(){
        @Override
        public void handleMessage(Message msg) {
          super.handleMessage(msg);
          //在子线程中调用handleMessage接受和处理message对象
          Log.e("sub thread","---------> msg.what = " + msg.what);
        }
      };

      mHandlerThread.sendEmptyMessage(1);
      /*
      /*
      //调用Looper.prepare（）方法
      Looper.loop();
      */
      */
    }
  }).start();

}

很不幸，崩溃了！

使用Handler的两个经典异常：

CalledFromWrongThreadException：这种异常是因为尝试在子线程中去更新UI，进而产生异常。

Can’t create handle inside thread that ha not called Looper.prepared：是因为我们在子线程中去创建Handler，而产生的异常。

修改方式，调用Looper.prepare()方法，将上面的注释放开。

4.异步消息处理——Handler

深入源码解析Android中的Handler,Message,MessageQueue,Looper

android之handler机制深入解析

Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系

Android多线程----异步消息处理机制之Handler详解

Android进阶——深入浅出Handler（一）

Handler 、 Looper 、Message 这三者都与Android异步消息处理线程相关的概念。那么什么叫异步消息处理线程呢？

异步消息处理线程启动之后处于无限循环体中，每循环一次，则从内部消息队列中取出一条消息，然后回掉相关消息处理函数。

执行完一个消息之后会继续循环，若消息队列为空，则线程阻塞等待。

Looper负责创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息，而消息的创建者就是一个或多个Handler 。

Looper的核心方法

Looper的构造方法：

private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
  //构造方法主要是创建消息队列
        mRun = true;
        mThread = Thread.currentThread();
}

prepare()方法

public static final void prepare() {
  //sThreadLocal是一个ThreadLocal对象，可以在一个线程中存储变量。
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(true));
}

第5行行代码中将一个Looper的实例放入了ThreadLocal，并且2-4行判断了sThreadLocal是否为null，否则抛出异常。这也就说明了Looper.prepare()方法不能被调用两次，同时也保证了一个线程中只有一个Looper实例。

loop方法：

public static void loop() {
        final Looper me = myLooper();
  //返回了sThreadLocal存储的Looper实例，如果me为null则抛出异常，也就是说looper方法必须在prepare方法之后运行。
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
  //拿到该looper实例中的mQueue（消息队列）
        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);
		//把消息交给msg的target的dispatchMessage方法去处理，即实现消息分发。
        //Msg的target是什么呢？其实就是handler对象
            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();
        }
}

Looper主要作用：

1、 与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。

2、 loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。

好了，我们的异步消息处理线程已经有了消息队列（MessageQueue），也有了在无限循环体中取出消息的哥们，现在缺的就是发送消息的对象了，于是乎：Handler登场了。

5.理解一下

Android系统中专门启动一个线程用于异步消息处理，从都源码可以看到该线程为sLocalThread，该线程中启动一个Looper对象，Looper对象中的Loop()函数负责遍历消息队列和分发消息，每一个Looper中有且仅有一个MessageQueue，该对象用于保存所有的msg。

可以理解为 one loop per thread （陈硕在muduo的设计理念中提到）。

10.一个坑爹的问题——为什么在有些时候子线程中是可以直接更新UI的？

子线程中可以使用Handler吗？