Handler 原理

Handler （源码级之一）

handler表示一个消息处理器，用于解决在android中，多线程之间相互传递消息的一种机制，==原因==是，android开发中，我们通过会使用子线程（单独的线程）去处理耗时的操作，如果在子线程（工作线程）中直接访问主线程（UI线程）中的UI组件（UI工具包），从android4.0开始这个操作是被拒绝的，目的是为了防止多线程并发访问主线程的UI组件，而导致UI组件的线程安全问题，所以子线程不能直接访问UI线程。那子线程想要访问UI线程的UI组件，怎么办？android提供了Handler机制来实现。所有想要访问UI组件的子线程，可以通过Handler内部实现的消息对列（数据结构：先进先出。（数组，哈希表，栈，）），来依次间接的访问UI组件。具体是如何实现的呢？

示例：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private static final int UPDATE_NUMBER = 0X1;
    private TextView textView_data;
    private Button button_get;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView_data = (TextView) findViewById(R.id.textView_data);
        button_get = (Button) findViewById(R.id.button_get);
        button_get.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        new Thread(new MyThread()).start();
    }

    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what){
                case UPDATE_NUMBER:
                    button_get.setText(msg.arg1+"S");
                    break;
            }
        }
    };

    class MyThread implements Runnable{
        @Override
        public void run() {
            for (int i = 60; i >= 0; i--) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Message msg = handler.obtainMessage();
                msg.what = UPDATE_NUMBER;
                msg.arg1 = i;
                handler.sendMessage(msg);
            }
        }
    }
}

1、Handler API

发送消息的方法：
handler.sendMessage(msg);//发送一个消息到消息对列

//handler.sendEmptyMessage(UPDATE_NUMBER);

//handler.sendMessageDelayed(msg,3000);//延迟发送消息

//在指定时间发送消息

//handler.sendMessageAtTime(msg,System.currentTimeMillis()+3000);

//插队，发送消息到对队列的最前面,可以导致消息队列其它消息无法执行，

//队列错乱,一般不建议使用

//handler.sendMessageAtFrontOfQueue(msg);

2、handler的内部实现原理(面试题重点)

（1）阐述handler机制中适汲的4个对象：
Handler: 消息处理器，负责消息的发送和接收到消息后的处理

Message：消息对象

MessageQueue：消息对列

Looper：消息对列的处理器

（2）描述整个实现过程
在UI线程中创建一个Handler的子类对象，此时handler会绑定UI线程（主线程），此时会调用Looper.prepare()方法，创建一个消息对列的处理器对象，同时Looper对象的创建会创建一个与之对应的消息对列（MessageQueue），我们在子线程中通过调用Handler的send…方法，把一个消息对象添加到消息对列中，消息对象（++Message本身是使用链表数据结构，目的是为了重复使用消息对象，避免每次创建新的消息对象造成垃圾对象太多++），然后Looper对象==通过**loop()方法，来遍历消息对列，取出消息对象，再通过消息对象中保存的当前Handler对象的dispatchMessage方法来分发消息，dispatchMessage方法会回调handler中的handlerMessage方法，此时我们定义的handler子类对象的handlerMessage方法被调用，我们在这个方法中实现UI组件的更新或相关操作。

如果我们在子线程中创建Handler，我们必须手动调用Looper.prepare()方法来创建一个Looper对象，并且需要手动调用Looper.loop()方法来处理消息对列。

3、Handler内存泄露问题分析

内存泄露：对象在内存中，但无法引用， 称为内存泄露。

内存溢出： 内存不足，导致应用奔溃，异常退出，称为内存溢出。

两者之间的关系：内存泄露就会导致内存溢出。（作为一个合格程序员应该极力避免这种情况出现）。

内存泄露示例：

public class Main2Activity extends AppCompatActivity {

    private static final String TAG = "Main2Activity" ;
    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        //把当前任务加入到UI线程中执行
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    Log.i(TAG, "run: "+Thread.currentThread().getName()+"-"+i);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },5000);
        finish();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
    }
}  

为什么以上示例会导致内存泄露？

原因：Activity在执行finish操作后，其引用依然被handler对象持有，导致Activity对象不能被释放，（称为内存泄露），此操作过多，就可能出现内存溢出。通过这个问题的分析得出，任何对象在时行销毁操作时，如果对象的引用被其它对象持有，将无法回收。在Android开发中，由其是Activity和Service两个应用组件，需要我们特别注意。
所以我们的原则应该是：在结束应用组件时，必须考虑其内部引用对象的释放问题。

如何解决这个问题？

（1）在结束应用组件时，在onDestroy方法中释放资源。
在处理handler对象时，我们可以调用：
handler.removeCallbacksAndMessages(null);方法删除handler对列中的所有消息和回调。

（2）在其它类中引用activity或service对象时，内部类使用静态来修饰，然后把Activity对象的引用以弱引用的方式存在，以保正系统在内存不足时，可以回收activity。

private static class MyHandler extends Handler {
    //把activity的强引用转换为弱引用
    WeakReference<Main2Activity> weakReference;
    public MyHandler(Main2Activity activity){
        weakReference = new WeakReference<Main2Activity>(activity);
    }
    @Override
    public void handleMessage(Message msg) {
        Main2Activity activity = weakReference.get();
        if (activity != null) {
            //activity....
        }
    }
}

处理大图问题，也经常出现内存溢出。

WeakReference<Bitmap> weakReference;