Android（java）学习笔记145：Handler消息机制的原理和实现

 联合学习 Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系

 

1. 首先我们通过一个实例案例来引出一个异常：

（1）布局文件activity_main.xml：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity" >

    <TextView
        android:id="@+id/tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:text="@string/hello_world" />

</RelativeLayout>

（2）MainActivity.java：

package com.itheima.testthread;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends Activity {
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        System.out.println(Thread.currentThread().getName());
        final TextView tv = (TextView) findViewById(R.id.tv);
        new Thread() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                       tv.setText("哈哈哈"+i);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
        }.start();
    }

}

（3）布署程序到模拟器上，出现如下效果，程序直接stop;并且直接报出异常错误： 

 

报错：

 

android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

意思：从错误线程调用的异常。谁创建的view，谁才能修改编辑view，只有主线程才可以修改view（所有的View都是主线程创建的）。

上面的报错是ViewRootImpl对UI操作做了验证，这个验证工作是由ViewRootImpl的checkThread方法来完成的，如下所示：

void checkThread() {
        if(mThread != Thread.currentThread())  {
                throw new CalledFromWrongThreadException(" Only the
　　　　　　　　　　　　　　　　original thread that created a  view hierarchy can touch its views.");
         }
}

 

总结：上面报这个CalledFromWrongThreadException错误，是因为只有主线程才能修改View更新UI，但是我们这里却自己新建一个线程new Thread（）其中run（）的内容涉及到更新UI，这是不允许的，所有才会出现这样的错误警告。

 

但是往往我们编写程序的时候设计多个线程需要控制UI显示，但是我们上面已经说过了UI更新只能交给主线程，为了解决这个矛盾，解放程序员，google开发出来消息机制，用来子线程和主线程通信，子线程要更新UI，就会发送消息数据给主线程，这样主线程就会更新相应的UI界面，从而解决这个矛盾。

 

（4）系统为什么不允许在子线程中访问UI呢 ?

这是因为Android的UI控件不是线程安全的，如果在多线程中并发访问可能会导致UI控件处于不可预期的状态，那为什么系统不对UI控件的访问加锁呢? 缺点有两个：

首先加上锁机制会让UI访问的逻辑变得复杂；其次锁机制会降低UI访问的效率，这是因为锁机制会阻塞某些线程的执行。

鉴于这两个缺点，最简单且高效的方法就是采用单线程模型去处理UI操作，对于开发者来说也不是很麻烦，只需要通过Handler切换一下UI访问的执行线程即可。

2. 消息机制的原理和实现

消息机制实现逻辑图：

　　这里handler负责把外面的子线程的消息发到message queue消息队列之中，然后looper会以无限循环的形式查看message queue里面是不是有新消息，如果有的话，looper就把消息发送到handler，交给handler的handlemessage根据信息，更新UI，否则就一直等待。

　　Looper中还有一个特殊的概念，那就是ThreadLocal，ThreadLocal不是线程，它的作用是可以在每个线程中存储数据。我们知道，Handler创建的时候会采用当前的线程的Looper来构造消息循环系统，那么Handler内部如何获取当前线程的Looper呢 ? 这就是要使用ThreadLocal了，ThreadLocal可以在不同线程中互不干扰地存储并提供数据，通过ThreadLocal可以轻松获取每个线程的Looper。当然需要注意的是，线程默认是没有Looper，如果需要使用Handler就必须为线程创建Looper。我们经常提到的主线程，也叫UI线程，它就是ActivityThread，ActivityThread被创建时候就会初始化Looper，这也就是主线程中默认可以使用Handler的原因。

 

使用消息机制目的：

Android系统的主线程安全的系统，别的线程不可以修改ui线程的界面，如果子线程里面想要更新UI，就必须采用消息机制处理。

使用handler消息处理器编写代码步骤：

（1）在主线程里面声明消息处理器handler；

private Handler  handler = new  Handler()  { };

（2）子线程想要更新UI，利用消息机制

Message  msg  =  new Message();
msg.what  消息类型
msg.obj     具体消息携带的数据
handler.sendMessage(msg);

（3）系统内部有消息队列message queue和消息looper，轮询到消息，交给handler去处理：

（4）重写handler的方法处理消息：

public  void  handleMessage (Message msg)  {
                     //运行在主线程，更新UI

};

 

接下来我们就修改上面的案例，就更好理解这个消息机制：

MainActivity.java:

package com.itheima.testthread;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends Activity {
    private TextView tv;
    private Handler handler = new Handler() {
        public void handleMessage(Message msg) {
            // 运行在主线程，更新ui
            String str = (String) msg.obj;
            tv.setText(str);
            EditText et;
            
        };
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        System.out.println(Thread.currentThread().getName());
        tv = (TextView) findViewById(R.id.tv);
        new Thread() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    // tv.setText("哈哈哈"+i);
                    Message msg = new Message();
                    msg.obj = "哈哈哈" + i;
                    handler.sendMessage(msg);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
        }.start();
    }

}

acitivity_main.xml:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:text="@string/hello_world" />

</RelativeLayout>

 

 

3. Hanlder之 --- 传递Message --- 传递Runnable对象

 （1）简介：

　　一般来说在工作线程中执行耗时任务，当任务完成时，会返回UI线程，一般是更新UI。这时有两种方法可以达到目的。
　　一种是：handler.sendMessage。发一个消息，，它是一个Message，再根据消息，执行相关任务代码。
　　另一种是：handler.post(r)。r是要执行的任务代码，r是Runnable对象。意思就是说r的代码实际是在UI线程执行的。可以写更新UI的代码。（工作线程是不能更新UI的）

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

　　在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到Handler的消息队列中，然后，有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;
    
    @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界面。

 

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

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

public class HandlerActivity extends Activity {
    //声明两个按钮控件
    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之后将其再次发送进入消息队列中。

注意：

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

 

（4）多线程中传递Runnable对象

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

具体操作方法如下：

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
    }
    
    //定义类，这里只是定义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对象只是作为一个封装了操作的对象被传递，并未产生新线程。