第三章--Handler的二三事

本来写了开场白，算了，直接进入主题。

1、什么是Handler，作用是啥，为什么人人用了都说好。

Handler，我去查了一下字典，有处理者管理者的意思，它主要是负责线程之间的通信，比如UI线程（主线程）和其他线程之间的。那为什么一定要它负责通信呢，直接操作ui不行吗？当然不行，如果多个线程同时改变界面的属性值，那会变的很混乱，也叫做会导致线程安全问题。为此Android有一条必须遵守的规则：只允许UI线程修改Activity里的UI组件，是不是很霸气。但是这样其他线程就无法动态改变UI属性了，制定规则当然不是为了堵住一条路，Handler的作用这时候就体现出来了。
1、在新启动的线程中发送消息。
2、在主线程中处理消息。
比如你想改变界面上一张图片，线程中发个消息，Handler收到后立马乖乖的处理，然后给你修改。这么听话的东西怎么会没有人喜欢呢。

2、Handler简单使用

先贴代码

public class MainActivity extends Activity{
    //定义一个图片id数组
    int[] imageIds = new int[]{...};
    定义当前的显示的图片id
    int currentId = 0;
    @Override
    public void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        final ImageView show = (ImageView)findViewById(R.id.show);
        final Handler myHandler = new Handler(){
            @Override
            public void handleMessage(Message msg){
                if(msg.what == 0x1233){
                    //修改照片
                    show.setImageResource(imageIds[currentId++] % imageIds.length);
                }
            }
        }
        //计时器
        new Timer().schedule(new TimerTask(){
            @Override
            public void run(){
                myHandler.sendMessage(0x1233);
            }
        }, 0, 1200);
    }

}

这样就完成了一个自动播放图片的效果，定义了一个定时器，让它定时的sendMessage，实质上就是开了一个新的线程，由于android不允许在新线程中访问Activity里的界面组件，所以只能发个消息咯，Handler也就定时的改变图片，并且是循环的，在这里不得不说算法好厉害。另外布局文件就只有一个ImageView。

3、Looper,MessageQueue

其实Handler不是单打独斗，它还有几个好朋友，Looper和MessageQueue。

先说Looper

• 每个线程只能拥有一个Looper，不能有第二个，它的loop(）方法就是读取MessageQueue中的消息，读到之后就会把消息交给发送消息的Handler处理。看到这有人可能会说那你上面的Looper呢？别急，这是因为在UI线程也就是主线程中，系统已经初始了一个Looper，所以我们就不用了啊~~。但是如果是自己启动的线程，我在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()，最后是Looper.loop()。我们来看看Looper.prepare()做了一些什么。

     /** Initialize the current thread as a looper.
      * This gives you a chance to create handlers that then reference 这能让你在创建Handler的时候能引用Looper
      * this looper, before actually starting the loop. Be sure to call 在Looper使用前，必须保证调用了该方法
      * {@link #loop()} after calling this method, and end it by calling 调用之后，在loop()就停止了
      * {@link #quit()}.
      */
    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //这里应该就是new了Looper对象
        sThreadLocal.set(new Looper(quitAllowed));
    }

我用我蹩脚的英语翻译了一下，这个方法保证了线程中只有一个Looper对象。这似乎是使用了重载的方式调用，这样设计难道保证了封装的特性？
然后loop()的源码

    /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
        //没有调用prepare().会抛出异常
            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
        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.recycleUnchecked();
        }
    }

就是从MessageQueue中不断取出消息

然后MessageQueue

消息队列，它有一点神秘，自始至终都没有见过它，在loop()方法的源码中有这样一个语句final MessageQueue queue = me.mQueue;莫非Looper的构造器什么的里就有它？再次去瞧瞧：

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

原来啊系统在创建Looper对象的时候，就会在它的构造器中创建该对象。而且MessageQueue是采用先进先出的方式管理消息。

3、总结一下

使用线程中的Handler：
1、Loop.prepare()，它构造器也会创建配套的MessageQueue对象
2、创建Handler实例，重写handleMessage()方法
3、Looper.loop()。启动Looper.
4、没有第四

4、Handler的内存泄漏问题

视频中说到，如果Activity结束了，但是和其有关联的Handler还没有处理完它的消息，如果Handler不是静态的，就不会被Activity或者Service回收，Handler使用的内存就不会被释放，这就造成了内存泄漏问题。这里的一个解决方法，就是弱引用。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了具有弱引用的对象，都会回收它的内存。

public static class Testhandler extends Handler{

        public final WeakReference<HandlerButtonActivity> mHandlerButoonActivityWeakReference;

        public Testhandler(HandlerButtonActivity activity){
            mHandlerButoonActivityWeakReference = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            HandlerButtonActivity activity = mHandlerButoonActivityWeakReference.get();
            ...}
   }

---

大概会写点异步，老师提了一下，所以没弄懂啊啊啊啊