Handler android 传参 android中handler

转载

烟雨江南的秋 2025-03-21 08:20:26

文章标签 Handler android 传参 android Android thread Thread 文章分类 Android 移动开发

一、Handler的定义:

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

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

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

二、Handler一些特点

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

三、Handler中分发消息的一些方法

sendEmptyMessage(int)

sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.

四、应用实例：

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

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

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

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

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

视频教程中的例子：

1. public class HandlerActivity extends Activity {  
2.    
3.    //声明两个按钮控件 
4.    private Button startButton = null;  
5.    private Button endButton = null;  
6.    @Override 
7.    public void onCreate(Bundle savedInstanceState) {  
8.        super.onCreate(savedInstanceState);  
9.        setContentView(R.layout.main);  
10.        //根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器 
11.        startButton = (Button)findViewById(.startButton);  
12.        startButton.setOnClickListener(new StartButtonListener());  
13.        endButton = (Button)findViewById(.endButton);  
14.        endButton.setOnClickListener(new EndButtonListener());  
15.          
16.    }  
17.    class StartButtonListener implements OnClickListener{  
18. 
19.        @Override 
20.        public void onClick(View v) {  
21.            //调用Handler的post方法，将要执行的线程对象添加到队列当中 
22.            handler.post(updateThread);  
23.        }  
24.          
25.    }  
26.      
27.    class EndButtonListener implements OnClickListener{  
28. 
29.        @Override 
30.        public void onClick(View v) {  
31.            handler.removeCallbacks(updateThread);  
32.        }  
33.          
34.    }  
35.    //创建一个Handler对象 
36.    Handler handler  = new Handler();  
37.    //将要执行的操作写在线程对象的run方法当中 
38.    Runnable updateThread =  new Runnable(){  
39. 
40.        @Override 
41.        public void run() {  
42.            System.out.println("UpdateThread");  
43.            //在run方法内部，执行postDelayed或者是post方法 
44.            handler.postDelayed(updateThread, 3000);  
45.        }  
46.          
47.    };  
48. }

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

3， Handler和多线程

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

这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。

1. public class HandlerTest2 extends Activity {  
2. 
3.    @Override 
4.    protected void onCreate(Bundle savedInstanceState) {  
5.        // TODO Auto-generated method stub 
6.    super.onCreate(savedInstanceState);  
7.    setContentView(R.layout.main);  
8.    //打印了当前线程的ID 
9.    System.out.println("Activity-->" + Thread.currentThread().getId());  
10.    //生成一个HandlerThread对象 
11.    HandlerThread handlerThread = new HandlerThread("handler_thread");  
12.    //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程; 
13.    handlerThread.start();
14.    //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。 
15.     // HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程
16. ，可以处理消息循环； 其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是
17. 一一对应的。
18.    MyHandler myHandler = new MyHandler(handlerThread.getLooper());  
19.    Message msg = myHandler.obtainMessage();  
20.    //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象 
21.    Bundle b = new Bundle();  
22.    b.putInt("age", 20);  
23.    b.putString("name", "Jhon");  
24.    msg.setData(b);  
25.    msg.sendToTarget();  //将msg发送到myHandler
26.    }  
27.      
28.    //定义类
29.    class MyHandler extends Handler{  
30.    public MyHandler(){  
31.              
32.    }  
33.    
34.    public MyHandler(Looper looper){  
35.        super(looper);  
36.    }  
37.    @Override 
38.    public void handleMessage(Message msg) {  
39.        Bundle b = msg.getData();  
40.        int age = b.getInt("age");  
41.        String name = b.getString("name");  
42.        System.out.println("age is " + age + ", name is" + name);  
43.        System.out.println("Handler--->" + Thread.currentThread().getId());  
44.        System.out.println("handlerMessage");  
45.        }  
46.    }  
47. }

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

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

另外再强调一遍，在UI线程（主线程）中：

mHandler.post(new Runnable(){

执行代码..

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

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

--------------------------------------------------------------------------------------

在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]

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

2.使用Handler.post

[java]

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

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

3.Handler对Activity finish影响。

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

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。