Handler

一、Handler的定义:

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

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

二、Handler一些特点

        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对象到队列中，等待更新.

三、Handler实例

      (1) 子类需要继承Hendler类，并重写handleMessage(Message msg) 方法, 用于接受线程数据

      以下为一个实例，它实现的功能为 : 通过线程修改界面Button的内容

1. public class MyHandlerActivity extends Activity {
   
2.     Button button;
   
3.     MyHandler myHandler;
   
4. 
   
5.     protected void onCreate(Bundle savedInstanceState) {
   
6.         super.onCreate(savedInstanceState);
   
7.         setContentView(R.layout.handlertest);
   
8. 
   
9.         button = (Button) findViewById(R.id.button);
   
10.         myHandler = new MyHandler();
    
11.         // 当创建一个新的Handler实例时, 它会绑定到当前线程和消息的队列中,开始分发数据
    
12.         // Handler有两个作用, (1) : 定时执行Message和Runnalbe 对象
    
13.         // (2): 让一个动作,在不同的线程中执行.
    
14. 
    
15.         // 它安排消息,用以下方法
    
16.         // post(Runnable)
    
17.         // postAtTime(Runnable,long)
    
18.         // postDelayed(Runnable,long)
    
19.         // sendEmptyMessage(int)
    
20.         // sendMessage(Message);
    
21.         // sendMessageAtTime(Message,long)
    
22.         // sendMessageDelayed(Message,long)
    
23.       
    
24.         // 以上方法以 post开头的允许你处理Runnable对象
    
25.         //sendMessage()允许你处理Message对象(Message里可以包含数据,)
    
26. 
    
27.         MyThread m = new MyThread();
    
28.         new Thread(m).start();
    
29.     }
    
30. 
    
31.     /**
    
32.     * 接受消息,处理消息 ,此Handler会与当前主线程一块运行
    
33.     * */
    
34. 
    
35.     class MyHandler extends Handler {
    
36.         public MyHandler() {
    
37.         }
    
38. 
    
39.         public MyHandler(Looper L) {
    
40.             super(L);
    
41.         }
    
42. 
    
43.         // 子类必须重写此方法,接受数据
    
44.         @Override
    
45.         public void handleMessage(Message msg) {
    
46.             // TODO Auto-generated method stub
    
47.             Log.d("MyHandler", "handleMessage......");
    
48.             super.handleMessage(msg);
    
49.             // 此处可以更新UI
    
50.             Bundle b = msg.getData();
    
51.             String color = b.getString("color");
    
52.             MyHandlerActivity.this.button.append(color);
    
53. 
    
54.         }
    
55.     }
    
56. 
    
57.     class MyThread implements Runnable {
    
58.         public void run() {
    
59. 
    
60.             try {
    
61.                 Thread.sleep(10000);
    
62.             } catch (InterruptedException e) {
    
63.                 // TODO Auto-generated catch block
    
64.                 e.printStackTrace();
    
65.             }
    
66. 
    
67.             Log.d("thread.......", "mThread........");
    
68.             Message msg = new Message();
    
69.             Bundle b = new Bundle();// 存放数据
    
70.             b.putString("color", "我的");
    
71.             msg.setData(b);
    
72. 
    
73.             MyHandlerActivity.this.myHandler.sendMessage(msg); // 向Handler发送消息,更新UI
    
74. 
    
75.         }
    
76.     }
    
77. 
    
78. }
    

复制代码

 

 

handler（java中名称）编辑

本词条缺少概述、信息栏、名片图，补充相关内容使词条更完整，还能快速升级，赶紧来编辑吧！

目录

1特点

2分发消息方法

3和多线程

1特点编辑

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

在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，由Handler中的handlerMessage方法处理传过来的数据信息，并操作UI。当然，Handler对象是在主线程中初始化的，因为它需要绑定在主线程的消息队列中。

类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Message并进行相关操作。

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

Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。^[1] 

2分发消息方法编辑

post(Runnable)

postAtTime(Runnable,long)

postDelayed(Runnable,long)

sendEmptyMessage(int)

sendMessage(Message)

sendMessageAtTime(Message,long)

sendMessageDelayed(Message,long)^[2] 

3和多线程编辑

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

这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，当它被加入到消息队列中之后执行会占用很长的时间，以至于处于同一线程的其他操作无法继续执行，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。

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

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

Handler初探

2011-01-01 18:36:04

标签：多线程 Handler 休闲 android 职场

原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://52android.blog.51cto.com/2554429/470542

    Android中有着和J2SE同样优秀的多线程支持，可以把那些耗时较多的操作放在新线程中操作。但是当新线程中有涉及到操作UI的操作时，就会对主线程产生危险，因此，Android提供了Handler作为主线程和子线程的纽带。同时，Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定，因此可以利用Handler所包含的消息队列，制定一些操作的顺序。

   根据SDK文档的说明：“A Handler allows you to send and process Message and Runnable objects associated with a thread's MessageQueue.”由此可以清楚的知道，可以把消息和Runnble对象发送到与Handler对象所关联的消息队列中去。

    

     下面，就Handler的以上两点作用，分别进行讨论。

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

    在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，有Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。当然，Handler对象是在主线程中初始化的，以为它需要绑定在主线程的消息队列中。

    类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。

  

 
 

//Handler处理子线程消息代码示例：  
 
public class Activity01 extends Activity  
{  
    //声明ProgressBar对象  
    private ProgressBar m_ProgressBar;  
    private ProgressBar m_ProgressBar2;  
    private Button mButton01;  
    protected static final int GUI_STOP_NOTIFIER = 0x108;  
    protected static final int GUI_THREADING_NOTIFIER = 0x109;  
    public int intCounter=0;  
    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState)  
    {  
        super.onCreate(savedInstanceState);  
        //设置窗口模式，，因为需要显示进度条在标题栏  
        requestWindowFeature(Window.FEATURE_PROGRESS);  
        setProgressBarVisibility(true);  
        setContentView(R.layout.main);  
          
        //取得ProgressBar  
        m_ProgressBar = (ProgressBar) findViewById(R.id.ProgressBar01);  
        m_ProgressBar2= (ProgressBar) findViewById(R.id.ProgressBar02);  
        mButton01 = (Button)findViewById(R.id.Button01);   
          
        m_ProgressBar.setIndeterminate(false);  
        m_ProgressBar2.setIndeterminate(false);  
          
        //当按钮按下时开始执行,  
        mButton01.setOnClickListener(new Button.OnClickListener()  
        {  
          @Override 
          public void onClick(View v)  
          {  
            // TODO Auto-generated method stub  
                
              //设置ProgressBar为可见状态  
              m_ProgressBar.setVisibility(View.VISIBLE);  
              m_ProgressBar2.setVisibility(View.VISIBLE);  
              //设置ProgressBar的最大值  
              m_ProgressBar.setMax(100);  
              //设置ProgressBar当前值  
              m_ProgressBar.setProgress(0);  
              m_ProgressBar2.setProgress(0);  
 
              //通过线程来改变ProgressBar的值  
  new Thread(new Runnable() {  
     public void run()  
        {  
     for (int i = 0; i < 10; i++)  
        {  
           try 
           {  
                 intCounter = (i + 1) * 20;  
                 Thread.sleep(1000);  
 
            if (i == 4)  
            {  
            Message m = new Message();  
 
             m.what = Activity01.GUI_STOP_NOTIFIER;  
            Activity01.this.myMessageHandler.sendMessage(m);
   //将message发送到消息队列  
              break;  
             }  
            else 
           {  
           Message m = new Message();  
           m.what = Activity01.GUI_THREADING_NOTIFIER;  
           Activity01.this.myMessageHandler.sendMessage(m);  
  //将message发送到消息队列  
                                }  
                            }  
                            catch (Exception e)  
                            {  
                                e.printStackTrace();  
                            }  
                        }  
                    }  
                }).start();  
            }  
        });  
    }  
 
//通过匿名类复写Handler类中的handleMessage方法，用于接收传递到消息队列中的Message，并进行UI操作。
      Handler myMessageHandler = new Handler()  
      {  
        // @Override   
          public void handleMessage(Message msg)  
          {  
              switch (msg.what)  
              {  
              //ProgressBar已经是对大值  
              case Activity01.GUI_STOP_NOTIFIER:  
                  m_ProgressBar.setVisibility(View.GONE);  
                  m_ProgressBar2.setVisibility(View.GONE);  
                  Thread.currentThread().interrupt();  
                  break;  
              case Activity01.GUI_THREADING_NOTIFIER:  
                  if (!Thread.currentThread().isInterrupted())  
                  {  
                      // 改变ProgressBar的当前值  
                      m_ProgressBar.setProgress(intCounter);  
                      m_ProgressBar2.setProgress(intCounter);  
                        
                      // 设置标题栏中前景的一个进度条进度值  
                      setProgress(intCounter*100);  
                      // 设置标题栏中后面的一个进度条进度值  
                      setSecondaryProgress(intCounter*100);//  
                  }  
                  break;  
              }  
              super.handleMessage(msg);  
         }  
      };  
}  

    以上的例子中，子线程只是对进度条的参数进行了变更，并将结果以message形式发送到消息队列中去，子线程的内部并未进行UI操作，而是在重写的Handler的handlerMessage方法中操作了UI界面。

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

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

   

 

public class HandlerActivity extends Activity {  
    /** Called when the activity is first created. */ 
    //声明两个按钮控件  
    private Button startButton = null;  
    private Button endButton = null;  
    @Override 
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
        //根据控件的ID得到代表控件的对象，并未这两个按钮设置相应的监听器  
        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对象和消息。SDK文档中也提供了相关说明：

     When a process is created for your application, its main thread is dedicated to running a message queue that takes care of managing the top-level application objects (activities, broadcast receivers, etc) and any windows they create. You can create your own threads, and communicate back with the main application thread through a Handler. This is done by calling the same post or sendMessage methods as before, but from your new thread. The given Runnable or Message will than be scheduled in the Handler's message queue and processed when appropriate.

     具体操作方法如下：

 
 

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对象  
    HandlerThread handlerThread = new HandlerThread("handler_thread");  
    //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程;  
    handlerThread.start();
    //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。  
    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();  //将msg发送到myHandler
    }  
      
    //定义类
    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对象只是作为一个封装了操作的对象被传递，并未产生新线程。

Android Handler机制

分类： android应用开发 2011-05-13 14:48 61220人阅读 评论(45)收藏 举报

androidthreadcallbacknull数据结构string

在android中提供了一种异步回调机制Handler,使用它，我们可以在完成一个很长时间的任务后做出相应的通知

handler基本使用：

在主线程中，使用handler很简单，new一个Handler对象实现其handleMessage方法，在handleMessage中
提供收到消息后相应的处理方法即可，这里不对handler使用进行详细说明，在看本博文前，读者应该先掌握handler的基本使用，我这里主要深入描述handler的内部机制

.现在我们首先就有一个问题，我们使用myThreadHandler.sendEmptyMessage(0);发送一个message对象，那么Handler是如何接收该message对象并处理的呢？我先画一个数据结构图：

从这个图中我们很清楚可以看到调用sendEmptyMessage后，会把Message对象放入一个MessageQueue队列，该队列属于某个Looper对象，每个Looper对象通过ThreadLocal.set(new Looper())跟一个Thread绑定了，Looper对象所属的线程在Looper.Loop方法中循环执行从MessageQueue队列读取Message对象，并把Message对象交由Handler处理，调用Handler的dispatchMessage方法。

现在我们再来看一下使用Handler的基本实现代码：

// 主线程中新建一个handler
normalHandler = new Handler() {
public void handleMessage(android.os.Message msg) {
btnSendMsg2NormalHandler.setText("normalHandler");
Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--normalHandler handleMessage run...", Thread.currentThread()
.getName()));
}
};

...
//发送消息到hanlder
myThreadHandler.sendEmptyMessage(0);

你现在已经很清楚了sendEmptyMessage到handleMessage的过程，途中经过Looper.MessageQueue队列，转由Looper所在的线程去处理了，这是一个异步的过程，当然Looper所在的线程也可以是sendEmptyMessage所在的线程。

看了上面你也许还是迷惑不解，那么什么要Looper了，跟我们要用的Handler又有啥鸟关系呢？

我在前面一直强调在主线程中使用handler，为什么要这么说呢，因为你在自己new一个新线程中去像我前面那样简单建立一个Handler，程序执行是会报错的：

java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
at android.os.Handler.<init>(Handler.java:121)
at com.cao.android.demos.handles.HandleTestActivity$MyThread$1.<init>(HandleTestActivity.java:86)
at com.cao.android.demos.handles.HandleTestActivity$MyThread.run(HandleTestActivity.java:86)

为什么在主线程中不会报错，而在自己新见的线程中就会报这个错误呢？很简单，因为主线程它已经建立了Looper，你可以打开ActivityThread的源码看一下：

public static final void main(String[] args) {
SamplingProfilerIntegration.start();

Process.setArgV0("<pre-initialized>");

Looper.prepareMainLooper();

ActivityThread thread = new ActivityThread();
thread.attach(false);

Looper.loop();

if (Process.supportsProcesses()) {
throw new RuntimeException("Main thread loop unexpectedly exited");
}

thread.detach();
String name = (thread.mInitialApplication != null)
? thread.mInitialApplication.getPackageName()
: "<unknown>";
Slog.i(TAG, "Main thread of " + name + " is now exiting");
}

在main函数中它已经做了这个事情了，为什么要调用 Looper.prepareMainLooper(); Looper.loop();我们可以进去看一下，在prepareMainLooper方法中新建了一个looper对象，并与当前进程进行了绑定，而在Looper.loop方法中，线程建立消息循环机制，循环从MessageQueue获取Message对象，调用 msg.target.dispatchMessage(msg);进行处理msg.target在myThreadHandler.sendEmptyMessage(0)设置进去的，因为一个Thead中可以建立多个Hander，通过msg.target保证MessageQueue中的每个msg交由发送message的handler进行处理，那么Handler又是怎样与Looper建立联系的呢，在Handler构造函数中有这样一段代码：

mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;

在新建Handler时需要设置mLooper成员，Looper.myLooper是从当前线程中获取绑定的Looper对象：

public static final Looper myLooper() {
return (Looper)sThreadLocal.get();
}

若Looper对象没有创建，就会抛异常"Can't create handler inside thread that has not called Looper.prepare()"
这跟我前面讲的是一致的。所以我们在一个新线程中要创建一个Handler就需要这样写：

class MyThread extends Thread {

public void run() {
Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]-- run...", Thread
.currentThread().getName()));
// 其它线程中新建一个handler
Looper.prepare();// 创建该线程的Looper对象，用于接收消息,在非主线程中是没有looper的所以在创建handler前一定要使用prepare()创建一个Looper
myThreadHandler = new Handler() {
public void handleMessage(android.os.Message msg) {
Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--myThreadHandler handleMessage run...", Thread
.currentThread().getName()));
}
};
Looper.myLooper().loop();//建立一个消息循环，该线程不会退出
}
}

现在，你应该对Handler的机制有所了解了吧，若有什么疑问，欢迎在评论中提出

在其它线程中Handler使用主线程的Looper

前面我说了在新线程中要新建一个Handler需要调用Looper.prepare();也有另一种方法就是使用主线程中的Looper,那就不必新建Looper对象了:

threadMainLoopHandler =new Handler(Looper.getMainLooper()){
public void handleMessage(android.os.Message msg) {
Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--threadMainLoopHandler handleMessage run...", Thread
.currentThread().getName()));
}
//该handleMessage方法将在mainthread中执行
};

这时候注意不要在handleMessage做太多的操作，因为它在主线程中执行，会影响主线程执行ui更新操作。

使用Message.callback回调

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.使用Message.callback

[java] view plaincopyprint?

1. Message msg = Message.obtain(myThreadHandler,new Runnable() {
3. @Override
4. public void run() {
5. Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--myThreadHandler.Message.callback.run",
6. Thread.currentThread().getName()));
7. }
8. });
9. myThreadHandler.sendMessage(msg);

Message msg = Message.obtain(myThreadHandler,new Runnable() {@Overridepublic void run() {Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--myThreadHandler.Message.callback.run",Thread.currentThread().getName()));}});myThreadHandler.sendMessage(msg);

2.使用Handler.post

[java] view plaincopyprint?

1. myThreadHandler.post(new Runnable() {
3. @Override
4. public void run() {
5. Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--myThreadHandler.Message.callback.run",
6. Thread.currentThread().getName()));
7. }
8. });

myThreadHandler.post(new Runnable() {@Overridepublic void run() {Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--myThreadHandler.Message.callback.run",Thread.currentThread().getName()));}});

注：对于Handler机制相关测试，我写了一个测试类：

http://download.csdn.net/source/3275970

3.Handler对Activity finish影响。

在开发的过程中碰到一个棘手的问题，调用Activity.finish函数Acitivity没有执行生命周期的ondestory函数，后面查找半天是因为有一个handler成员，因为它有一个delay消息没有处理，调用Activity.finish，Activity不会马上destory，所以记得在Ativity finish前清理一下handle中的未处理的消息，这样Activity才会顺利的destory