Handler的简单使用

Handler是什么？
handler是android给我们用来更新UI的一套机制，它同时也是一套消息处理的机制，我们可以通过它发送消息，也可以通过它处理消息。（activity中的各个生命周期其实就是根据判断handler的不同msg进行处理的）

为什么要使用handler?
android在设计的时候就封装了一套消息的创建、传递、处理的机制，如果不遵循就没办法更新UI信息。

handler怎么用？看例子
—–handler的基本使用，例子包含了在线程中更新UI，返回线程中数据，发送延迟消息，发送循环消息，发送Message….

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Handler.Callback;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends Activity implements OnClickListener {

    private static Handler handler;
    private TextView tv_hello;
    private Button btn_stop;
    private Button btn_start;
    private int[] images;//存放图片的数组
    private ImageView iv_images;
    static final int MSG_WHAT_ONE = 0001;
    private MyRunnable mRunnable;
    private int index;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv_hello = (TextView) findViewById(R.id.tv_helloword);
        iv_images = (ImageView) findViewById(R.id.iv_images);
        btn_stop = (Button) findViewById(R.id.btn_stop);
        btn_stop.setOnClickListener(this);
        btn_start = (Button) findViewById(R.id.btn_start);
        btn_start.setOnClickListener(this);
        index = 0;
        mRunnable = new MyRunnable();
        images = new int[] { R.drawable.a, R.drawable.b, R.drawable.c,
                R.drawable.d, R.drawable.e, R.drawable.f, R.drawable.g };
        //初始化handler时一般是用空参，也可以传入一个Callback，callback可以对消息进行拦截
        handler = new Handler(new Callback() {

            @Override
            public boolean handleMessage(Message msg) {
                if (msg.what == MSG_WHAT_ONE) {
                    System.out.println("arg1 = " + msg.arg1 + ",arg2 = "
                            + msg.arg2 + ",obj = " + msg.obj+"callback");
                }
                //返回true则拦截消息，默认是false
                return true;
            }
        }) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                if (msg.what == MSG_WHAT_ONE) {
                    System.out.println("arg1 = " + msg.arg1 + ",arg2 = "
                            + msg.arg2 + ",obj = " + msg.obj);
                }
            }
        };
         changeUI();
         returnData();
//       showImages();

    }

    class MyRunnable implements Runnable {

        @Override
        public void run() {
            index++;
            index = index % 7;
            iv_images.setImageResource(images[index]);
            handler.postDelayed(mRunnable, 1500);
        }
    }

    public void showImages() {// 轮播图片
        handler.post(mRunnable);
    }

    public void changeUI() {// 更新UI
        handler.postDelayed(new Runnable() {

            @Override
            public void run() {
                tv_hello.setText("this is new text");
            }
        }, 1000);
    }

    public void returnData() {// 返回线程中数据
        new Thread() {
            public void run() {
                Message msg = new Message();
                // Message msg = handler.obtainMessage();
                msg.what = MSG_WHAT_ONE;
                msg.arg1 = 1;
                msg.arg2 = 2;
                msg.obj = "obj";
                handler.sendMessage(msg);
                // msg.sendToTarget();//用这种方式发送，初始化msg时必须用handler.obtainMessage();
            };
        }.start();
    }

    @Override
    public void onClick(View v) {
        int id = v.getId();
        if (id == R.id.btn_start) {//开始轮播
            showImages();
            Toast.makeText(MainActivity.this, "你点击了开始", Toast.LENGTH_SHORT)
                    .show();

        }
        if (id == R.id.btn_stop) {//停止轮播
            // 把这个runnable从该handler中移除
            handler.removeCallbacks(mRunnable);
            Toast.makeText(MainActivity.this, "你点击了停止", Toast.LENGTH_SHORT)
                    .show();
        }
    }
}

最根本的目的是解决多线程并发问题
假设一个Activity中有多个线程去更新UI，并且都没有加锁机制，那么就会产生更新界面混乱的问题，如果对更新UI的操作都进行加锁处理则会造成性能的下降。
对于这个问题android给我们提供了一套更新UI的机制，我们只要遵循这个机制就可以了，根本不用去关心多线程的问题，所以更新UI的操作，都是在主线程的消息队列中去轮询处理的。

接下来看一下Handler与looper和MessageQueue的关系；
—Handler封装了消息的发送（主要包括消息发送给谁）
Looper
1、内部包含一个消息队列即MessageQueue，所有的Handler发送的消息都走向这个消息队列
2、Looper.looper方法，就是一个死循环，不断的从MessageQueue中取消息，如果有消息就处理消息，没有就阻塞

—MessageQueue，就是一个消息队列，可以添加消息并处理消息

—Handler也很简单，它内部会跟looper进行关联，也就是说在handler的内部可以找到looper，找到了looper也就找到了MessageQueue，在handler中发送消息，其实就是向MessageQueue队列中发送消息

总结一下：handler负责发送消息，looper负责接受handler发送的消息，并直接把消息回传给handler自己，MessageQueue就是一个存储消息的容器。