Android学习历程10-Handler消息传递机制

　　在上一篇博客介绍了Android 中常见的两种事件处理机制——基于监听的事件处理和基于回调的事件处理，接下来写一些关于handle消息传递机制的东西，在Android学习历程中已经做了一些关于handle消息传递机制的一些说明，这里做一些简单补充。
　　Android的消息机制是另一种形式的“事件处理”，这种机制是为了解决Android应用的多线程问题。–Android平台不允许Activity新启动的线程访问Activity里的界面组件，这样会导致新启动的线程无法修改界面组件的属性值，此时我们需要通过Hander的消息机制来实现了。

Handler简介

1、 Handler作用：
　　1）执行计划任务，可以在预定的时间执行某些任务，可以模拟定时器

　　2）线程间通信。在Android的应用启动时，会创建一个主线程，主线程会创建一个消息队列来处理各种消息。当你创建子线程时，你可以在你的子线程中拿到父线程中创建的Handler 对象，就可以通过该对象向父线程的消息队列发送消息了。由于Android要求在UI线程中更新界面，因此，可以通过该方法在其它线程中更新界面。
2、控制消息的发送和接受的时机
　　通过回调的方法来实现，开发者需要重写Handler类中处理消息的方法，当新启动的线程发送消息时，Handler类中处理消息的方法被自动回调。
3、Handler类包含如下方法用于发送、处理消息
. void handleMessage(Message msg)：处理消息的方法。该方法通常用于被重写

. final boolean hasMessages(int what):检查消息队列中是否包含what属性为指定值的消息

. final boolean hasMessages(int what,Object object) ：检查消息队列中是否包含what属性为指定值
的消息且object属性为指定对象的消息

. 多个重载的Message obtainMessage()：获取消息

. sendEmptyMessage(int what):发送空消息

. final boolean sendEmptyMessageDelayed(int what,long delayMills):指定多少秒后发送空消息

. final boolean sendMessage(Message msg)：立即发送消息

. final boolean sendMessageDelayed(Message msg,long delayMills)：指定多少秒后发送消息

handle 中的角色描述

1） Looper: 一个线程可以产生一个Looper对象，由它来管理此线程里的Message Queue.Looper扮演着一个Handler和 消息队列之间通讯桥梁的角色。程序组件首先通过Handler把 消息传递给Looper，Looper把 消息放入队列。Looper也 把消息队列里的消息广播给所有的Handler，Handler接 受到消息后调用handleMessage进 行处理。

2） Handler: 你可以构造Handler对象来与Looper沟通，以便push 新消息到 Message Queue里，或者
接收Looper从Message Queue 里所送来的消息。

3）Message Queue（消息队列）：Message Queue是一个消息队列，用来存放通过Handler发 布的消息。消息队列通常附属于某一个创建它的线程，可以通过Looper.myQueue()得 到当前线程的消息队列。如果没有消息队列对象则会抛出空指针异常 。Android在 第一次启动程序时会默认会为UI thread创建一个关联的消息队列，用来管理程序的一些上层组件，activities，broadcast receivers 等等。你可以在自己的子线程中创建Handler与UI thread通讯。也就是说我们程序一启动我们的UI线程也就是主线程就会有一个消息队列 ，而如果我们自己另外开启的一个子线程就不会有MessageQueue(消息队列)对象。这一点大家务必知道。

4）线程：UI thread 通常就是 main thread，而Android 启动程序时会替它建立一个Message Queue。

每一个线程里可含有一个 Looper 对象以及一个 Message Queue 数据结构。在你的应用程序里，
可以定义 Handler 的子类别来接收 Looper 所送出的消息。

Handler 的执行过程

每个handler 对应一个线程 thread , 在子线程中 handler 发送的消息会进入到 Message Queue当中去，由 looper 再来分发给 Handler 处理。

Handler 用例

详细请见：http://www.open-open.com/lib/view/open1426249917873.html

1、Handler 用例1

　　这个例子是最简单的介绍handler使用的,是将handler绑定到它所建立的线程中.本次实验完成的功能是:单击Start按钮，程序会开始启动线程，并且线程程序完成后延时1s会继续启动该线程，每次线程的run函数中完成对界面输出 nUpdateThread…文字，不停的运行下去，当单击End按钮时，该线程就会停止，如果继续单击Start，则文字又开始输出了。

MainActivity.java:

package com.example.handler1;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private TextView text_view = null;
private Button start = null;
private Button end = null;

//使用handler时首先要创建一个handler
Handler handler = new Handler();
//要用handler来处理多线程可以使用runnable接口，这里先定义该接口
//线程中运行该接口的run函数
Runnable update_thread = new Runnable()
{
    public void run()
    {
        //线程每次执行时输出"UpdateThread..."文字,且自动换行
        //textview的append功能和Qt中的append类似，不会覆盖前面
        //的内容，只是Qt中的append默认是自动换行模式
        text_view.append("\nUpdateThread...");
        //延时1s后又将线程加入到线程队列中
        handler.postDelayed(update_thread, 1000);

    }
};

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    text_view = (TextView)findViewById(R.id.text_view);
    start = (Button)findViewById(R.id.start);
    start.setOnClickListener(new StartClickListener());
    end = (Button)findViewById(R.id.end);
    end.setOnClickListener(new EndClickListener());

}
private class StartClickListener implements OnClickListener
{
    public void onClick(View v) {
        // TODO Auto-generated method stub
        //将线程接口立刻送到线程队列中
        handler.post(update_thread);
    }               
}

private class EndClickListener implements OnClickListener
{
    public void onClick(View v) {
        // TODO Auto-generated method stub
        //将接口从线程队列中移除
        handler.removeCallbacks(update_thread);
    }

}
}

activity_main.xml:

<LinearLayout 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"
android:orientation="vertical" >
<TextView
    android:id="@+id/text_view"
    android:layout_width="fill_parent"
    android:layout_height="200dip"
    android:text="@string/hello_world"
    tools:context=".MainActivity" />
<Button
    android:id="@+id/start"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/start"
    />
<Button
    android:id="@+id/end"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/end"
    />
</LinearLayout>

2、Handler使用例2

　　这个例子比刚才那个例子稍微复杂些。因为这个例子中用到了handler的消息队列机制，即通过handler中一个线程向消息队列中用 sendMessage方法发送消息，发送的消息当然可以用来传递参数。在handler中用handleMessage来处理消息，处理方法是获得消息 队列中的消息参数，用这些参数来完成另外一些功能。
　　本实验实现的是当开始按钮按下时，会启动一个线程，并绑定到handler中，该线程发送带有参数的message到handler的消息队列中，消息队列的另一端获取该消息，并且用该消息的参数来更新进度条。

MainActivity.java:

package com.example.handler2;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ProgressBar;
public class MainActivity extends Activity {
private ProgressBar progress_bar = null;
private Button start = null;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    progress_bar = (ProgressBar)findViewById(R.id.progress_bar);
    start = (Button)findViewById(R.id.start);

    start.setOnClickListener(new StartOnClickListenr());
}

private class StartOnClickListenr implements OnClickListener
{
    public void onClick(View v) {
        // TODO Auto-generated method stub
        //让进度条显示出来
        progress_bar.setVisibility(View.VISIBLE);
        //将线程加入到handler的线程队列中
        update_progress_bar.post(update_thread);

    }
}
//创建一个handler，内部完成处理消息方法
Handler update_progress_bar = new Handler()
{
    @Override
    public void handleMessage(Message msg) {
        // TODO Auto-generated method stub
        //super.handleMessage(msg);
        //显示进度条
        progress_bar.setProgress(msg.arg1);
        //重新把进程加入到进程队列中
        update_progress_bar.post(update_thread);
    }      
};//不加这个分号则不能自动添加代码

Runnable update_thread = new Runnable()
{
    int i = 0;
    public void run() {
        // TODO Auto-generated method stub
        i += 10;
        //首先获得一个消息结构
        Message msg = update_progress_bar.obtainMessage();
        //给消息结构的arg1参数赋值
        msg.arg1 = i;
        //延时1s，java中的try+catch用来排错处理
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        //把消息发送到消息队列中
        update_progress_bar.sendMessage(msg);
        if(i == 100)
            //把线程从线程队列中移除
            update_progress_bar.removeCallbacks(update_thread);
    }      
};
}

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" >
<Button
    android:id="@+id/start"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:layout_alignParentBottom="true"
    android:text="@string/start"
    />
<ProgressBar
    android:id="@+id/progress_bar"
    android:layout_width="fill_parent"
    android:layout_height="100dip"
    android:layout_alignParentTop="true"
    style="?android:attr/progressBarStyleHorizontal"
    android:visibility="gone"
    />
</RelativeLayout>

3、 Handler使用例3

　　上面2个例子表面上看handler使用了post方法启动了runnbale，其实启动的线程和activity主线程是同一个线程，因为它只是 运行了线程的run方法，而不是start方法。Mars老师实验3的目的是为了验证仅使用handler的post方法是否处于同一个线程。
　　该实验在主activtiy的onCreate函数中打印了2条关于本线程的信息，然后创建一个handler并为它绑定一个线程，在线程的run方法中也打印了线程的信息，观察2者的信息是否一样。
结果如下：
　　说明这2个线程确实是同一线程，并且可以看出主界面中的文字大概过了10s才显示出来，因为语句 setContentView(R.layout.activity_main);放在了handler的post启动语句后面，而handler绑定的 线程中又延时了10s，所以同时也证明了只有是同一个线程才会出现这种情况。

程序主要代码和注释如下：

MainActivity.java:

package com.example.handler3;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.Menu;
public class MainActivity extends Activity {
//新建一个handler
private Handler handler = new Handler();
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    //将runnable加载到handler的线程队列中去
  //  handler.post(r);       
    Thread t = new Thread(r);
    t.start();
    setContentView(R.layout.activity_main);
    //打印activtiy线程信息
    System.out.println("activity_id---->"+Thread.currentThread().getId());
    System.out.println("activity_name---->"+Thread.currentThread().getName());
}
Runnable r = new Runnable()
{
    public void run() {
        // TODO Auto-generated method stub
        //打印新建线程信息
        System.out.println("handler_id---->"+Thread.currentThread().getId());
        System.out.println("handler_name---->"+Thread.currentThread().getName());
        //延时10s，为了观察主界面中内容出现的时间
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

};
}

如果把语句：

handler.post(r);

换成：

Thread t = new Thread(r);
t.start();

其它的不变，则程序运行时主界面内容立刻就显示出来了，且系统输出如下：
这2者都说明这样绑定的线程与它所在的activity线程就不是同一个线程了。

Handler使用例4

这个例子将学会怎样不使用runnable来启动一个线程，而是用HandlerThread的looper来构造一个handler，然后该handler自己获得消息，并传递数据，然后又自己处理消息，当然这是在另一个线程中完成的。

消息结构中传递简单的整型可以采用它的参数arg1和arg2，或者传递一些小的其它数据，可以用它的object，该object可以是任意的对 象。当需要传送比较大的数据是，可以使用消息的setData方法，该方法需要传递一个Bundle的参数。Bundle中存放的是键值对的map，只是 它的键值类型和数据类型比较固定而已。

程序主要代码和注释如下：

MainActivity.java:

package com.example.handler4;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.view.Menu;
public class MainActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    System.out.println("activity_ID---->"+Thread.currentThread().getId());
    //新建一个HanderThread对象，该对象实现了用Looper来处理消息队列的功能
    HandlerThread handler_thread = new HandlerThread("handler_thread");
    handler_thread.start();
    //MyHandler类是自己继承的一个类，这里采用hand_thread的Looper来初始化它
    MyHandler my_handler = new MyHandler(handler_thread.getLooper());
    //获得一个消息msg
    Message msg = my_handler.obtainMessage();

    //采用Bundle保存数据，Bundle中存放的是键值对的map，只是它的键值类型和数据类型比较固定而已
    Bundle b = new Bundle();
    b.putString("whether", "晴天");
    b.putInt("temperature", 34);
    msg.setData(b);
  //将msg发送到自己的handler中，这里指的是my_handler,调用该handler的HandleMessage方法来处理该mug
    msg.sendToTarget();
}
class MyHandler extends Handler
{
    //空的构造函数
    public MyHandler()
    {}
    //以Looper类型参数传递的函数，Looper为消息泵，不断循环的从消息队列中得到消息并处理，因此
    //每个消息队列都有一个Looper，因为Looper是已经封装好了的消息队列和消息循环的类
    public MyHandler(Looper looper)
    {
        //调用父类的构造函数
        super(looper);
    }
    @Override
    public void handleMessage(Message msg) {
        // TODO Auto-generated method stub
        System.out.println("Handler_ID---->"+Thread.currentThread().getId());
        System.out.println("Handler_Name---->"+Thread.currentThread().getId());
        //将消息中的bundle数据取出来
        Bundle b = msg.getData();
        String whether = b.getString("whether");
        int temperature = b.getInt("temperature");
        System.out.println("whether= "+whether+" ,temperature= "+temperature);
    }

}
}