Android的Handler机制的一些理解

Handler是什么

在Android中表示一种消息处理机制或者叫消息处理方法，用来循环处理应用程序主线程各种消息，比如UI的更新，按键、触摸消息事件等。

为什么Android要用Handler机制

Android应用程序启动时，系统会创建一个主线程，负责与UI组件（widget、view）进行交互，比如控制UI界面界面显示、更新等；分发事件给UI界面处理，比如按键事件、触摸事件、屏幕绘图事件等，因此，Android主线程也称为UI线程。
由此可知，UI线程只能处理一些简单的、短暂的操作，如果要执行繁重的任务或者耗时很长的操作，比如访问网络、数据库、下载等，这种单线程模型会导致线程运行性能大大降低，甚至阻塞UI线程，如果被阻塞超过5秒，系统会提示应用程序无相应对话框，缩写为ANR，导致退出整个应用程序或者短暂杀死应用程序。

除此之外，单线程模型的UI主线程也是不安全的，会造成不可确定的结果。线程不安全简单理解为：多线程访问资源时，有可能出现多个线程先后更改数据造成数据不一致。比如，A工作线程（也称为子线程）访问某个公共UI资源，B工作线程在某个时候也访问了该公共资源，当B线程正访问时，公共资源的属性已经被A改变了，这样B得到的结果不是所需要的的，造成了数据不一致的混乱情况。
线程安全简单理解为：当一个线程访问功能资源时，对该资源进程了保护，比如加了锁机制，当前线程在没有访问结束释放锁之前，其他线程只能等待直到释放锁才能访问，这样的线程就是安全的。

基于以上原因，Android的单线程模型必须遵守两个规则：
1.  不要阻塞UI线程；
2.  不要在UI线程之外访问UI组件，即不能在子线程访问UI组件，只能在UI线程访问。

因此，Android系统将大部分耗时、繁重任务交给子线程完成，不会在主线程中完成，解决了第一个难题；同时，Android只允许主线程更新UI界面，子线程处理后的结果无法和主线程交互，即无法直接访问主线程，这就要用到Handler机制来解决此问题。基于Handler机制，在子线程先获得Handler对象，该对象将数据发送到主线程消息队列，主线程通过Loop循环获取消息交给Handler处理。

案例用法

下面两个案例都实现一个定时器，每隔一秒显示数字0-9

案例1：sendMenssage方法更新UI界面

package com.example.testhandler;
 
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
 
public class TestHandlerActivity extends Activity {
 
    protected static final String TAG = "TestHandlerActivity";
    private Button sendButton;
    private TextView displayText;
 
    Handler mHandler = new Handler() {
 
        @Override
        public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            if (msg.what == 99) {
                int i = msg.getData().getInt("displayKey");
                displayText.setText(i + "");
            }
            super.handleMessage(msg);
        }
 
    };
    private Button exitButton;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initViews();
    }
 
    private void initViews() {
 
        displayText = (TextView) findViewById(R.id.display_text);
        sendButton = (Button) findViewById(R.id.send_button);
        sendButton.setOnClickListener(buttonOnClickListener);
        exitButton = (Button) findViewById(R.id.exit_button);
        exitButton.setOnClickListener(buttonOnClickListener);
    }
 
    OnClickListener buttonOnClickListener = new OnClickListener() {
 
        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
            if (v.getId() == R.id.send_button) {
                new Thread(new WorkRunnable()).start();
            } else if (v.getId() == R.id.exit_button) {
                finish();
            }
        }
 
    };
 
    class WorkRunnable implements Runnable {
        @Override
        public void run() {
            // TODO Auto-generated method stub
            int i = 0;
            while (i < 10) {
                Message msg = mHandler.obtainMessage(99);
                Bundle bundle = new Bundle();
                bundle.putInt("displayKey", i);
                msg.setData(bundle);
                mHandler.sendMessage(msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                i++;
            }
        }
    }
 
    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        if (mHandler != null) {
            if (mHandler.hasMessages(99)) {
                mHandler.removeMessages(99);
            }
            mHandler = null;
        }
        super.onDestroy();
    }
}

WorkRunnable的run方法中进行了耗时操作，要把结果反馈给UI，需要Handler发送消息给UI线程，在Handler的handleMessage对消息进行处理

案例2： postDelayed更新UI

package com.example.postdelaydemo;
 
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
 
public class PostDelayActivity extends Activity {
    protected static final String TAG = "PostDelayActivity";
    private Button sendButton;
    private TextView displayText;
    private Button exitButton;
    Handler mHandler = new Handler();
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initViews();
    }
 
    private void initViews() {
        displayText = (TextView) findViewById(R.id.display_text);
        sendButton = (Button) findViewById(R.id.send_button);
        sendButton.setOnClickListener(buttonOnClickListener);
        exitButton = (Button) findViewById(R.id.exit_button);
        exitButton.setOnClickListener(buttonOnClickListener);
    }
 
    OnClickListener buttonOnClickListener = new OnClickListener() {
        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
            if (v.getId() == R.id.send_button) {
                mHandler.postDelayed(new PostDelayRunnable(), 1000);
            } else if (v.getId() == R.id.exit_button) {
                finish();
            }
        }
    };
 
    class PostDelayRunnable implements Runnable {
        int i = 0;
 
        @Override
        public void run() {
            // TODO Auto-generated method stub
            if (i >= 10) {
                mHandler.removeCallbacks(this);
            } else {
                displayText.setText(getResources().getString(
                        R.string.display_label)
                        + i);
                mHandler.postDelayed(this, 1000);
            }
            i++;
        }
    }
 
    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        if (mHandler != null) {
            mHandler = null;
        }
        super.onDestroy();
    }
}

postDelayed方法把runnable对象作为消息放到队列中等待执行，run方法中就是具体执行过程。

msg.target是Handler的一个对象引用，handler对象发送消息暂存到消息队列，Looper取出消息分发给相应的handler处理。

Handler.post(new Runnable())和sendmessage(msg)区别

(1)  都是把消息放到消息队列等待执行，前者放的是一个runnable对象，后者是一个message对象；
(2)  前者最终还是会转化成sendMessage，只不过最终的处理方式不一样，前者会执行runnable的run方法；后者可以被安排到线程中执行。

(3)  两者本质没有区别，都可以更新UI，区别在于是否易于维护等。

HandlerThread是什么

HandlerThread继承了Thread，是一个包含有looper的线程类。正常情况下，除了主线程，工作线程是没有looper的，但是为了像主线程那样也能循环处理消息，Android也自定义一个包含looper的工作线程——HandlerThread类。

啊啊啊啊啊啊啊啊西吧太菜了，源码看不懂