当我们在处理下载或是其它须要长时间运行的任务时。假设直接把处理函数放在Activity的OnCreate或是OnStart中。会导致运行过程中整个Activity无响应，假设时间过长，程序就会挂掉。

Handler就是把这些功能放到一个当初的线程里运行，与Activity互不影响。

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

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

　　解释：当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发。比方说，你要是点击一个button，android会分发事件到button上。来影响你的操作。假设此时须要一个耗时的操作，比如:联网读取数据。或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，假设你放在主线程中的话，界面会出现假死现象,假设5秒钟还没有完毕的话。会收到Android系统的一个错误提示"强制关闭". 这个时候我们须要把这些耗时的操作，放在一个子线程中,由于子线程涉及到UI更新，可是当子线程中有涉及到操作UI的操作时，就会对主线程产生危急，也就是说，更新UI仅仅能在主线程中更新，在子线程中操作是危急的. 这个时候，Handler就出现了,来解决这个复杂的问题，因为Handler执行在主线程中(UI线程中)，它与子线程能够通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传递)Message对象，(里面包括数据), 把这些消息放入主线程队列中，配合主线程进行更新UI。

二、Handler一些特点

        handler能够分发Message对象和Runnable对象到主线程中, 每一个Handler实例,都会绑定到创建他的线程中(通常是位于主线程), 也就是说Handler对象初始化后。就默认与对它初始化的进程的消息队列绑定，因此能够利用Handler所包括的消息队列，制定一些操作的顺序。

      它有两个作用: (1):  安排消息或Runnable 在某个主线程中某个地方运行, (2)安排一个动作在不同的线程中运行

Handler中分发消息的一些方法

        post(Runnable)

        postAtTime(Runnable,long)

        postDelayed(Runnablelong)

        post类方法同意你排列一个Runnable对象到主线程队列中

        sendEmptyMessage(int)

        sendMessage(Message)

        sendMessageAtTime(Message,long)

        sendMessageDelayed(Message,long)

        sendMessage类方法, 同意你安排一个带数据的Message对象到队列中

三、handler的简单工作原理图

四、应用实例：

   1。传递Message。

用于接受子线程发送的数据, 并用此数据配合主线程更新UI。

          在Android中。对于UI的操作通常须要放在主线程中进行操作。假设在子线程中有关于UI的操作。那么就须要把数据消息作为一个Message对象发送到消息队列中，然后，用Handler中的handlerMessge方法处理传过来的数据信息。并操作UI。类sendMessage(Messagemsg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。

  2，传递Runnable对象。用于通过Handler绑定的消息队列。安排不同操作的运行顺序。

Handler对象在进行初始化的时候，会默认的自己主动绑定消息队列。利用类post方法，能够将Runnable对象发送到消息队列中，依照队列的机制按顺序运行不同的Runnable对象中的run方法。

另外，Android的CPU分配的最小单元是线程。Handler通常是在某个线程里创建的。因而Handler和Thread就是相互绑定的。一一相应。而Runnable是一个接口，Thread是Runnable的子类。所以说。他俩都算一个进程。

mars_androids视频中的代码

package mars.handler;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class HandlerActivity extends Activity {
    /** Called when the activity is first created. */
	//声明两个button控件
	private Button startButton = null;
	private Button endButton = null;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        //依据控件的ID得到代表控件的对象，并未这两个button设置对应的监听器
        startButton = (Button)findViewById(R.id.startButton);
        startButton.setOnClickListener(new StartButtonListener());
        endButton = (Button)findViewById(R.id.endButton);
        endButton.setOnClickListener(new EndButtonListener());
        
    }
    class StartButtonListener implements OnClickListener{

		@Override
		public void onClick(View v) {
			//调用Handler的post方法。将要运行的线程对象加入到队列其中
			handler.post(updateThread);
		}
    	
    }
    
    class EndButtonListener implements OnClickListener{

		@Override
		public void onClick(View v) {
			handler.removeCallbacks(updateThread);
		}
    	
    }
    //创建一个Handler对象
    Handler handler  = new Handler();
    //将要运行的操作写在线程对象的run方法其中
    Runnable updateThread =  new Runnable(){

		@Override
		public void run() {
			System.out.println("UpdateThread");
			//在run方法内部，运行postDelayed或者是post方法
			handler.postDelayed(updateThread, 3000);
		}
    	
    };
}

程序的执行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是由于实现了Runnable接口的updateThread对象进入了空的消息队列即被马上执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。

3.Handler和多线程

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

    这样对于那些简单的操作，似乎并不会影响。可是对于耗时较长的操作。就会出现“假死”。

为了解决问题，就须要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息

package mars.handler;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;

public class HandlerTest2 extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		//打印了当前线程的ID
		System.out.println("Activity-->" + Thread.currentThread().getId());
		//生成一个HandlerThread对象。实现了使用Looper来处理消息队列的功能，这个类由Android应用程序框架提供
		HandlerThread handlerThread = new HandlerThread("handler_thread");
		//在使用HandlerThread的getLooper()方法之前，必须先调用该类的start();
		handlerThread.start();
		//将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper取代handler初始化时默认绑定的消息队列来处理消息。  
                // HandlerThread顾名思义就是能够处理消息循环的线程。它是一个拥有Looper的线程能够处理消息循环；  
                //事实上与其说Handler和一个线程绑定，倒不如说Handler和Looper是一一相应的。
		MyHandler myHandler = new MyHandler(handlerThread.getLooper());
		Message msg = myHandler.obtainMessage();
		//将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象
		Bundle b = new Bundle();
		b.putInt("age", 20);
		b.putString("name", "Jhon");
		msg.setData(b);
		msg.sendToTarget();
	}
	
	class MyHandler extends Handler{
		public MyHandler(){
			
		}
		public MyHandler(Looper looper){
			super(looper);
		}
		@Override
		public void handleMessage(Message msg) {
			Bundle b = msg.getData();
			int age = b.getInt("age");
			String name = b.getString("name");
			System.out.println("age is " + age + ", name is" + name);
			System.out.println("Handler--->" + Thread.currentThread().getId());
			System.out.println("handlerMessage");
		}
	}
}

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

这里须要注意。这里用到的多线程并不是由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象仅仅是作为一个封装了操作的对象被传递，并未产生新线程。

在UI线程（主线程）中：

    mHandler=newHandler();

    mHandler.post(newRunnable(){

    void run(){

       //运行代码..

     }

    });

    这个线程事实上是在UI线程之内执行的，并没有新建线程。

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

    Thread thread = newThread();

    thread.start();

    HandlerThreadthread = new HandlerThread("string");

    thread.start();