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就是一个存储消息的容器。