Android攻城狮Handler简介

Handler是什么？
Handler是Android提供的一套用来更新UI的机制，也是一套消息处理机制，可以通过它发送消息，也可以通过它处理消息。
所有Activity生命周期回调的方法（例如onCreate()、onDestory()等等），都是通过handler机制去发送消息的，然后根据不同的消息（message）做相应的分支处理。例如发送一个消息给 Framework，告知需要调用onCreate()或onDestory()方法。实际上在 Framework 当中，Activity的交互大部分都是用AMS（Activity Manager Service）做处理的。整个应用程序的核心的一个类就是 Activity Thread，Activity Thread就是通过handler机制接收到 Activity Manager Service发送的有关Activity生命周期的管理的消息（比如启动）。

为什么要使用Handler？
Android在设计的时候，就封装了一套消息的创建、传递、处理机制，如果不遵循这样的机制，就没有办法更新UI信息，并且会抛出异常信息。这样的机制便包含Handler机制。

1. 我们要创建一个handler的时候，它会和默认的一个线程进行绑定，而这个默认的线程当中就有一个MessageQueue（消息队列）。
2. handler的两个用途：（1）定时发送一个Messages或者Runnables对象；（2）可以在一个线程当中去处理并执行一个Action的动作。
3. 主线程运行一个消息队列，并管理着一些顶级的应用对象（top-level application objects），包括Activity、Broadcast Receiver等等，这些对象默认都是创建在Activity Thread（也就是我们常说的UI线程或者主线程）当中。

Handler的示例，实现图片轮播。
代码实现
1. 在主布局中定义一个ImageView控件。
2. 在 MainActivity 中创建并初始化ImageView，定义一个图片数组 images 和数组下标索引 index，创建一个Handler对象。
3. 创建一个内部类 MyRunnable 实现 Runnable 接口，重写 run() 方法：
   public void run() {
       index++;
       index = index%3; // 图片轮播（一般是通过ViewPager实现图片轮播）
       imageView.setImageResource(images[index]);
       handler.postDelayed(myRunnable,1000); // 每隔一秒换一次图片
   }
4. 在onCreste()方法中调用handler，也就是在主线程中调用handler：
   handler.postDelayed(myRunnable,1000);

  1 public class MainActivity extends ActionBarActivity {
  2      private Handler handler1 = new Handler();
  3     private Handler handler2 = new Handler(new Callback() {
  4
  5         @Override
  6         public boolean handleMessage(Message msg) {
  7             // TODO Auto-generated method stub
  8             Toast.makeText(getApplicationContext(), "1", 1).show();
  9             return false;// 若设为true则后边不执行
 10         }
 11     }) {
 12
 13         public void handleMessage(Message msg) {
 14             // TODO Auto-generated method stub
 15             Toast.makeText(getApplicationContext(), "2", 1).show();
 16         }
 17
 18     };
 19
 20
 21     private Handler handler3 = new Handler() {
 22         public void handleMessage(android.os.Message msg) {
 23             // textView.setText(""+msg.arg1+"-"+msg.arg2);
 24             textView.setText("" + msg.obj);
 25         };
 26     };
 27
 28
 29     private TextView textView;
 30     private ImageView imageView;
 31     private int Image[] = { R.drawable.a, R.drawable.b, R.drawable.c };
 32     private int index;
 33
 34     @Override
 35     protected void onCreate(Bundle savedInstanceState) {
 36         super.onCreate(savedInstanceState);
 37         setContentView(R.layout.fragment_main);
 38         textView = (TextView) findViewById(R.id.textview);
 39         imageView = (ImageView) findViewById(R.id.imageView1);
 40         new Thread() {
 41             public void run() {
 42                 try {
 43                     Thread.sleep(2000);
 44                     // (1)
 45                     // Message message=new Message();
 46                     // message.arg1=88;
 47                     // message.arg2=100;
 48
 49                     // (2)
 50                     Message message = handler3.obtainMessage();
 51
 52                     Person person = new Person();
 53                     person.age = 23;
 54                     person.name = "zy";
 55                     message.obj = person;
 56                     // handler.sendMessage(message);//（1）
 57                     message.sendToTarget();// (2)
 58
 59                 } catch (InterruptedException e) {
 60                     // TODO Auto-generated catch block
 61                     e.printStackTrace();
 62                 }
 63             };
 64         }.start();
 65
 66         /*
 67          * new Thread() {
 68          * public void run() {
 69          * try { Thread.sleep(1000);
 70          * handler.post(new Runnable() {
 71          *
 72          * @Override
 73          * public void run() {
 74          *  // TODO Auto-generated method stub
 75          * textView.setText("更新线程"); } });
 76          *
 77          * } catch (InterruptedException e) { // TODO Auto-generated catch block
 78          * e.printStackTrace(); } }; }.start();
 79          */
 80
 81         handler1.postDelayed(myRunnable, 1000);// 1000:一秒钟换一次
 82
 83     }
 84
 85     MyRunnable myRunnable = new MyRunnable();
 86 //图片循环播放
 87     class MyRunnable implements Runnable {
 88
 89         @Override
 90         public void run() {
 91             // TODO Auto-generated method stub
 92             index++;
 93             index = index % 3;
 94             imageView.setImageResource(Image[index]);
 95             handler1.postDelayed(myRunnable, 1000);
 96         }
 97     }
 98
 99     class Person {
100         public int age;
101         public String name;
102
103         @Override
104         public String toString() {
105             // TODO Auto-generated method stub
106             return "name=" + name + "age=" + age;
107         }
108     }
109
110     public void click(View view) {
111         handler1.removeCallbacks(myRunnable);
112         handler2.sendEmptyMessage(1);
113     }
114
115 }

Android为什么要设计只能通过Handler机制更新UI呢？
最根本的目的就是解决多线程并发的问题。
1. 假如在一个Activity当中，有多个线程去更新UI，并且都没有加锁机制，那么会产生什么样子的问题？
--> 更新界面混乱。
2. 如果对更新UI的操作都进行加锁处理的话又会产生什么样子的问题？
--> 性能下降。
正是对以上问题的考虑，Android给我们提供了一套更新UI的机制，我们只需遵循这样的机制就可以了，根本不用去关心多线程（并发）的问题，所有的更新UI的操作，都是在主线程的消息队列中去“轮询”处理的。

Handler的原理是什么？
面试经典问题：Looper、Handler、Message（或MessageQueue）三者间的关系？
一、Handler封装了消息的发送（主要是将消息发送给谁（默认是Handler自己），以及什么时候发送）。
Looper：
1.内部包含一个消息队列 MessageQueue，所有的 Handler 发送的消息都走向（加入）这个消息队列。
2.Looper.Looper方法，就是一个死循环，不断地从 MessageQueue 取得消息，如果有消息就处理消息，没有消息就阻塞。
二、MessageQueue
MessageQueue 就是一个消息队列，可以添加消息，并处理消息。
三、Handler 也很简单，内部会跟 Looper 进行关联，也就是说，在 Handler 的内部可以找到 Looper，找到了 Looper 也就找到了 Message。在 Handler 中发送消息，其实就是向 MessageQueue 队列中发送消息。

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