Android--Handler

一：定义

主要接收子线程发送的数据, 并用此数据配合主线程更新UI，用来跟UI主线程交互用。

比如可以用handler发送一个message，然后在handler的线程中来接收、处理该消息，以避免直接在UI主线程中处理事务导致影响UI主线程的其他处理工作，Android提供了Handler作为主线程和子线程的纽带；也可以将handler对象传给其他进程，以便在其他进程中通过handler给你发送事件；还可以通过handler的延时发送message，可以延时处理一些事务的处理。

通常情况下，当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发。如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候，不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象,如果5秒钟还没有完成的话，会收到Android系统的一个错误提示”强制关闭”. 而子线程是不能直接操作UI！

此时就需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，当子线程中有涉及到操作UI的操作时，就会对主线程产生危险，也就是说，更新UI只能在主线程中更新，在子线程中操作是危险的. 这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传递)Message对象，(里面包含数据), 把这些消息放入主线程队列中，配合主线程进行更新UI。

二:特点：

handler可以分发Message对象和Runnable对象到主线程中， 每个Handler实例，都会绑定到创建他的线程中(一般是位于主线程)，它有两个作用：

(1)安排消息或Runnable 在某个主线程中某个地方执行；

(2)安排一个动作在不同的线程中执行。

Handler中分发消息的一些方法

post(Runnable)
postAtTime(Runnable，long)
postDelayed(Runnable long)
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message，long)
sendMessageDelayed(Message，long)

以上post类方法允许你排列一个Runnable对象到主线程队列中，

sendMessage类方法， 允许你安排一个带数据的Message对象到队列中，等待接收，然后更新相关数据。

三：使用

—-1：简单例子

public class FristActivity extends AppCompatActivity implements View.OnClickListener {
TextView textView;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_frist);
textView = (TextView) findViewById(R.id.textMsg);
findViewById(R.id.sendBtn).setOnClickListener(this);
}

Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 2:
textView.setText("msg.what=2");
break;
}
super.handleMessage(msg);
}
};

@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.sendBtn:
Message message = new Message();
message.what = 2;
handler.sendMessage(message);
break;
}
}
}

—-2：发送一个空消息

//1 注意第一种与第二种参数不一样的问题
Message message = new Message();
message.what = 0;
handler.sendMessage(message);
//2：比第一种方式更节省运行内存
Message message1 = handler.obtainMessage();
message1.arg1 = 0;
handler.sendMessage(message1);
//3直接调用系统提供的方法
handler.sendEmptyMessage(0);

—-3：稍微复杂一点的例子：

public class OneActivity extends AppCompatActivity {

TextView textView;

MyHandler myHandler;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_frist);
textView = (TextView) findViewById(R.id.textMsg);
myHandler = new MyHandler();
MyThred m = new MyThred();
new Thread(m).start();
}

class MyHandler extends Handler {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Bundle bundle = msg.getData();
String msgString = bundle.getString("msg");
textView.setText(msgString);
}
}

class MyThred extends Thread {
@Override
public void run() {
super.run();
try {
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
Message message = myHandler.obtainMessage();
Bundle bundle = new Bundle();
bundle.putString("msg", "msg=====null");
message.setData(bundle);

myHandler.sendMessage(message);
}
}

}

—-4：从消息队列中移除<避免重复发送消息>

myHandler.removeMessages(int what);

myHandler.removeMessages(int what,Object o);

myHandler.removeCallbacksAndMessages(Object o);

myHandler.removeCallbacks(Runnable r,Object o);

myHandler.removeMessages(int what);

myHandler.removeCallbacks(Runnable r);

—-5：<简单操作可以使用本例子>

运行结果是每隔三秒就打印出来数据。

—-是因为实现了Runable接口，runable对象进入了空的消息队列即被立即执行Run方法，而在Run方法内部，在三秒之后将其再次发送到消息队列里面。

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.button).setOnClickListener(this);
findViewById(R.id.button2).setOnClickListener(this);
}

Handler handler = new Handler();

Runnable runnable = new Runnable() {
@Override
public void run() {
Log.i("start", "start");
handler.postDelayed(runnable, 3000);
}
};

@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.button:
handler.post(runnable);
break;
case R.id.button2:
handler.removeCallbacks(runnable);
break;
}
}
}

总结：

post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。

—-6：

<
HandlerThread就是可以处理消息循环的线程，它是一个拥有Looper的线程,可以处理消息循环；说Handler和一个线程绑定，倒不如说Handler和Looper是一一对应的
>

–1：获取当前线程的ID

Thread.currentThread().getId()

–2：HandlerThread

–3：创建一个HandlerThread，即创建了一个包含Looper的线程<在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程>

HandlerThread       handlerThread = new HandlerThread("leochin.com");
handlerThread.start();       //创建HandlerThread后一定要记得start()

–4：获取HandlerThread的Looper

Looper looper =  handlerThread.getLooper();

–5：创建Handler，通过Looper初始化

Handler handler = new Handler(looper);

通过以上三步我们就成功创建HandlerThread。通过handler发送消息，就会在子线程中执行。

如果想让HandlerThread退出，则需要调用handlerThread.quit();

在使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。<参考前面例子>

–7:重点:

在主线程通过Handler handler = new Handler();即使用默认构造函数构造Handler时，是默认使用主线程的Looper对象，通过这种方式构造的Handler是属于主线程的，也就是Handler和Looper是绑定在一起的，如果构造Handler时指定一个新线程的Looper对象，则该Handler对象是属于该子线程的。

mHandler=new Handler();
mHandler.post(new Runnable(){
void run(){

}
});

这个线程其实是在UI线程之内运行的，并没有新建线程！

常见的新建线程的方法是：

Thread thread = new Thread();
thread.start();

HandlerThread thread = new HandlerThread("string");
thread.start();

—-8：

UI线程它已经建立了Looper，因为主线程默认有一个自己的Looper对象和Message对象，非主线程默认是没有自己的Looper，需要自己去创建：通过Looper.prepare创建一个Looper对象，以及 Looper.loop()创建消息循环队列；在新线程（非主线程）中创建Handler对象，有两种方法实现：

1–创建Handler之前通过 Looper.prepare()方法创建Looper对象;<非主线程>

Looper.prepare();// 创建该线程的Looper对象，用于接收消息,在非主线程中是没有looper的所以在创建handler前一定要使用prepare()创建一个Looper
Handler myThreadHandler = new Handler(){}；

2–使用主线程的Looper对象，因为每个主线程默认已经创建了自己的Looper对象;

<Looper.getMainLooper()><主线程>

Handler threadMainLoopHandler = new Handler(Looper.getMainLooper()){}；

—-9：

在一个新线程中要创建一个Handler就需要这样写：

class MyThread extends Thread {
public void run() {
myThreadHandler = new Handler() {
public void handleMessage(Message msg{

}
};
Looper.myLooper().loop();//建立一个消息循环，该线程不会退出
}
}

四：源码分析：

—-MessageQueue队列

—–队列属于某一个Looper

—–每个Looper对象通过ThreadLocal.set(new Looper())跟一个Thread绑定

—-Looper对象所属的线程在Looper.Loop方法中循环执行从MessageQueue队列读取Message对象，并把Message对象交由Handler处理，调用Handler的dispatchMessage方法

参考：http://blog.csdn.net/stonecao/article/details/6417364

五：源码：

public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}

dispatchMessage定义看出，如果Message对象自带callback对象，handler不会执行handleMessage方法而是执行message.callback中定义的run方法，当然callback还是在handler关联的looper所绑定的线程中执行的。实际上Handler.post(Runnable r)方法就是把r添加到一个msg.callback中。

—-1：

Handler handler = new Handler();

Message message = Message.obtain(handler, new Runnable() {
@Override
public void run() {

}
});
handler.sendMessage(message);

—-2：

Handler handler = new Handler();

handler.post(new Runnable() {
@Override
public void run() {

}
});

以上两种方式来说，代码功能没有区别！

注意：本文里面一些创建Handler的方式并不是都说最好的，有些只是为了演示简化步骤，故在使用过程中，请注意按照最优的创建方式创建对象并使用！