开发环境为android4.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);
}
}
@override
public boolean oncreateoptionsmenu(menu menu) {
getmenuinflater().inflate(r.menu.activity_main, menu);
return true;
}
}
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>
handler使用例2
这个例子比刚才那个例子稍微复杂些。因为这个例子中用到了handler的消息队列机制，即通过handler中一个线程向消息队列中用sendmessage方法发送消息，发送的消息当然可以用来传递参数。在handler中用handlemessage来处理消息，处理方法是获得消息队列中的消息参数，用这些参数来完成另外一些功能。
本实验实现的是当开始按钮按下时，会启动一个线程，并绑定到handler中，该线程发送带有参数的message到handler的消息队列中，消息队列的另一端获取该消息，并且用该消息的参数来更新进度条。
软件打开后：
单击start按钮后，更新的进度条结果如下（怎么感觉4.1版本android进度条那么小呢？不懂该怎么设置）：
实验主要部分代码和注释：
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);
}
};
@override
public boolean oncreateoptionsmenu(menu menu) {
getmenuinflater().inflate(r.menu.activity_main, menu);
return true;
}
}
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>
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();
}
}
};
@override
public boolean oncreateoptionsmenu(menu menu) {
getmenuinflater().inflate(r.menu.activity_main, menu);
return true;
}
}
如果把语句：
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);
}
}
@override
public boolean oncreateoptionsmenu(menu menu) {
getmenuinflater().inflate(r.menu.activity_main, menu);
return true;
}
}
总结：
android中的handler可以用来完成异步的消息出来，即发送消息和接收消息相互独立，可以同时运行。在例1和例2中，实际上handler中使用的线程是与它所在的activity处于同一个主线程，因为handler中调用的runnable接口是直接运行该接口的run函数的，而不是start函数。例3专门比较了这2中情况。例4学会使用怎样在新线程中处理消息的方法。
作者：tornadomeet