Handler使用总结

一、最常见的子线程通过Handler发送Msg来刷新主界面：

    private final static int TAG1 = 1;
    private Button button;
    private TextView text;
    MyHandler myHandler;

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        myHandler = new MyHandler();
        // 当创建一个新的Handler实例时, 它会绑定到当前线程和消息的队列中,开始分发数据
        // Handler有两个作用,
        // (1) : 定时执行Message和Runnalbe 对象
        // (2): 让一个动作,在不同的线程中执行.
        // 它安排消息,用以下方法
        // post(Runnable)
        // postAtTime(Runnable,long)
        // postDelayed(Runnable,long)
        // sendEmptyMessage(int)
        // sendMessage(Message);
        // sendMessageAtTime(Message,long)
        // sendMessageDelayed(Message,long)
        // 以上方法以 post开头的可以处理Runnable对象
        // sendMessage()可以处理Message对象(Message里可以包含数据,)
    }

    @Override
    public void onClick(View v) {

        switch (v.getId()) {
        case R.id.bu1:
            MyThread m = new MyThread();
            new Thread(m).start();
            break;

        default:
            break;
        }
    }

    /**
     * 用以接受消息,处理消息 ,此Handler会与当前主线程一块运行
     * */
    private class MyHandler extends Handler {

        // 默认构造函数
        public MyHandler() {
            super();
        }

        // 带有Looper参数的构造函数
        @SuppressWarnings("unused")
        public MyHandler(Looper L) {
            super(L);
        }

        // 子类必须重写此方法,处理消息
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            // 根据msg的类型来处理数据
            switch (msg.what) {
            caseTAG1:
                // 此处可以更新UI
                Bundle b = msg.getData();
                String color = b.getString("color");
                String btn = msg.obj.toString();
                text.append(color + btn);
                break;

            default:
                break;
            }
        }
    }

    /** Thread用以处理耗时的后台操作，并实时将数据通过Handler添加到MessageQueue中
     *  Looper再从MessageQueue中取出，disptch给相应的处理函数*/
    class MyThread implements Runnable {
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /** 使用Message能够传递多种数据具体可以参考Message的源码
                最常用的可以使用Message的obj对象在线程之间传递对象数据*/
            // Message msg  =  new Message();
            // 宜采用从Message池中获取msg，这样能够节省内存
            Message msg = myHandler.obtainMessage();
            msg.what = TAG1;
            Bundle b = new Bundle();// 存放数据
            b.putString("color", "Red");
            msg.setData(b);
            msg.obj = new String("Button"); // Data用于存放大数据，obj存放小数据
            myHandler.sendMessage(msg); // 向Handler发送消息,更新UI
        }
    }

    private void initView(){
        button = (Button) findViewById(R.id.bu1);
        button.setOnClickListener(this);
        text = (TextView) findViewById(R.id.text);
    }

1、引申：如果使用Handler设计到对Activity本身的引用，比如想在handleMessage中使用Toast,就需要Activity的Context
如果Acivity销毁，而Handler却依然保持对该Activity的引用，则会造成内存泄露；在代码中也会提示HandlerLeak
解决方法可以有如下两种，最根本的解决方法是第二种使用弱引用；
1）使用全局变量getApplicationContext(）的方法
2）使用弱引用方式：

 /*** 使用此方法来避免内存泄露HandlerLeak **/
    private static class MyContextHandler extends Handler{
        /* 建立弱引用 */
        private WeakReference<MyHandlerActivity> mOuter;

        /* 构造函数 */
        public MyContextHandler(MyHandlerActivity activity) {
            mOuter = new WeakReference<MyHandlerActivity>(activity);
        }

        /** 处理函数*/
        public void handleMessage(Message msg) {
            // 防止内存泄露
            MyHandlerActivity outer = mOuter.get();
            if (outer != null) {
                outer.handleservice(msg);
            }
        }
    }

    /** 消息处理函数 */
    private void handleservice(Message msg) {
        // 根据msg的类型来处理数据
        switch (msg.what) {
        case TAG1:
            // 此处可以更新UI
            Bundle b = msg.getData();
            String color = b.getString("color");
            String btn = msg.obj.toString();
            Toast.makeText(MyHandlerActivity.this, color + btn, Toast.LENGTH_SHORT).show();
            break;
        default:
            break;
        }
    }

2、post、postDelayed、removeCallBacks:的简单使用：
可用于延时更新主界面，或者设置定时器

 private Button bu1, bu2;
    private TextView text , text2;
    private Handler mHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initView();
        mHandler = new Handler();    
        bu1.setOnClickListener(this);
        bu2.setOnClickListener(this);
    }

    //Runnable线程
    Runnable updateRunnable = new Runnable() {
        @Override
        public void run() {
            text.append("a");
        }
    };

    Runnable cicleRunnable = new Runnable() {
        @Override
        public void run() {
            text2.append("b");
            // 实现效果会是每隔一秒循环添加
            mHandler.postDelayed(cicleRunnable, 1000);
        }
    };

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.bu1:
            // 直接添加到MessageQueue中
//          mHandler.post(updateRunnable);
            // 延迟1s添加到MessageQueue中
            mHandler.postDelayed(updateRunnable, 1000);
            mHandler.post(cicleRunnable);
            break;
        case R.id.bu2:
            // 取消Runnable的执行
            mHandler.removeCallbacks(updateRunnable);
            mHandler.removeCallbacks(cicleRunnable);
            break;

        default:
            break;
        }
    }

二、Handler使用的一些变种：
1、runOnUiThread,更新主界面；
可以用于一些能够获取到Activity的引用，对其主界面进行直接操作的场景：

    activity.runOnUiThread(new Runnable() {   
        @Override
        publicvoid run() {
            Activity.getSomeTextView().setText("aaaaa");
        }
    });

2、View的post和postDelayed方法
和Handler的post与postDelayed用法相同，方法中Runnable运行在主线程中：

 text.post(new Runnable() {
        @Override
        publicvoid run() {
            button.setText("aaaa");
        }
    });

    text.postDelayed(new Runnable() {
        @Override
        publicvoid run() {
            button.setText("bbbb");
        }
    }, 2000);

3、HandlerThread:
在我们的应用程序当中为了实现同时完成多个任务，所以我们会在应用程序当中创建多个线程。为了让多个线程之间能够方便的通信，我们会使用Handler实现线程间的通信。
下面我们看看如何在线程当中实例化Handler。在线程中实例化Handler我们需要保证线程当中包含Looper(注意：UI-Thread默认包含Looper)。
为线程创建Looper的方法如下：在线程run()方法当中先调用Looper.prepare()初始化Looper,然后再run()方法最后调用Looper.loop()，这样我们就在该线程当中创建好Looper。(注意：Looper.loop()方法默认是死循环)
我们实现Looper有没有更加简单的方法呢?当然有，这就是我们的HandlerThread。我们来看下Android对HandlerThread的描述：
Handy class for starting a new thread that has a looper. The looper can then be used to create handler classes. Note that start() must still be called.
HandlerThread要注意start，start之后，是一个含有一个looper的新线程。这个looper可以用来创建其他的Handler对象；

三种Handler创建方式及简单使用对比如下：

 private Handler uiHandler;  // 主UI线程
    private Handler mainHandler;// HandlerThread线程Handler
    private Handler subHandler; // 普通线程Handler

    protectedvoid onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        // 启动HandlerThread,这里简化了Handler的创建流程
        HandlerThread handlerThread = new HandlerThread("mHandlerThread");
        handlerThread.start();

        mainHandler = new Handler(handlerThread.getLooper()){
            @Override
            public void handleMessage(Message msg){
                switch (msg.what) {
                case 1:
                    // 注：这里已经不是主UI线程，不能操作主界面
//                  text.setText("11111");
                    Log.i("TAG", "11111");
                    break;
                }
            }
        };

        // 标准的子线程Handler创建流程
        SubThread subThread = new SubThread();
        subThread.start();

        uiHandler = new Handler(getMainLooper()){
            @Override
            public void handleMessage(Message msg){
                switch (msg.what) {
                case 3:
                    text.setText("33333");
                    Log.i("TAG", "3333");
                    break;
                }
            }
        };
    }

    // 普通线程创建Handler流程（这里书写得并不标准，会造成内存泄露）
    private class SubThread extends Thread{
        @Override
        public void run(){
            Looper.prepare();

            subHandler = new Handler(){
                @Override
                public void handleMessage(Message msg){
                    switch (msg.what) {
                    case 2:
                        // 这里是子线程，无法更新UI界面
//                      text.setText("22222");
                        Log.i("TAG", "2222");
                        break;
                    }
                }
            };

            Looper.loop();
        }
    }

    @Override
    publicvoid onClick(View v) {

        switch (v.getId()) {
        case R.id.bu1:         
            mainHandler.sendEmptyMessage(1);
            break;
        case R.id.bu2:         
            subHandler.sendEmptyMessage(2);
            break;
        case R.id.bu3:         
            uiHandler.sendEmptyMessage(3);
            break;
        default:
            break;
        }
    }

由之前分析过得handler与Looper之间的关系也可以看出，Handler处理事件及其所在线程与其相关的Looper相关；Looper使用TLS机制保存，是线程唯一的；

4、异步事务处理AsyncTask:
AsyncTask类为将耗时的操作移到后台线程，并在操作中同步更新UI线程实现了最佳的实践模式及封装。
在Android中实现异步任务机制有两种方式，Handler和AsyncTask。
Handler模式需要为每一个任务创建一个新的线程，任务完成后通过Handler实例向UI线程发送消息，完成界面的更新，这种方式对于整个过程的控制比较精细，但也是有缺点的，例如代码相对臃肿，在多个任务同时执行时，不易对线程进行精确的控制。
AsyncTask的声明如下：

public abstract class AsyncTask<Params, Progress, Result>

泛型函数，明显看出后面三个数据类型分别对应于参数类型，返回进度数据类型，以及最终返回结果数据类型；使用实例为下：

private class myAsyncTask extends AsyncTask<String, Integer, String>
{
    //执行前先进性的初始化操作（可选）
    @Override
    protected void onPreExecute() {
    }

    //Task操作主体（abstract函数，必须重写）
    //参数（String类型），由execute传递过来
    @Override
    protected String doInBackground(String... params) {
        return null;
    }

    //运行在UI线程（可选）
    //实时更新进度条等UI元素
    @Override
    protected void onProgressUpdate(Integer... progress){
    }

    //doInBackground完成后，返回值会传入事件处理程序中（可选）
    @Override
    protected void onPostExecute(String result){
    }   
}

代码中使用得：

    new myAsyncTask().execute(params);

5、IdlerHandler：
使用IdlerHandler可以向当前线程的消息队列里发送操作，这些操作之后在空闲的时候才会执行，它们的优先级非常低。需要注意的是queueIdle的方法可以返回一个布尔值，如果返回false，说明IdleHandler执行一次之后就会被删除，如果返回true，说明IdleHandler一直是有效的，只要系统处于空闲状态就执行IdleHandler的queueIdle方法。使用方式如下：

    Looper.myQueue().addIdleHandler(new IdleHandler() {
        @Override
        public boolean queueIdle() {
            text.setText("4444");
            return false;
        }
    });