Handler使用例1

这个例子是最简单的介绍handler使用的,是将handler绑定到它所建立的线程中.

本次实验完成的功能是:单击Start按钮，程序会开始启动线程，并且线程程序完成后延时1s会继续启动该线程，每次线程的run函数中完成对界面输出nUpdateThread...文字，不停的运行下去，当单击End按钮时，该线程就会停止，如果继续单击Start，则文字又开始输出了。

软件界面如下：

实验主要部分代码和注释：

MainActivity.java:

1 packagecom.example.handler1;2 importandroid.app.Activity;3 importandroid.os.Bundle;4 importandroid.os.Handler;5 importandroid.view.Menu;6 importandroid.view.View;7 importandroid.view.View.OnClickListener;8 importandroid.widget.Button;9 importandroid.widget.TextView;10

11 public class MainActivity extendsActivity {12

13 private TextView text_view = null;14 private Button start = null;15 private Button end = null;16

17 //使用handler时首先要创建一个handler

18 Handler handler = newHandler();19 //要用handler来处理多线程可以使用runnable接口，这里先定义该接口20 //线程中运行该接口的run函数

21 Runnable update_thread = newRunnable()22 {23 public voidrun()24 {25 //线程每次执行时输出"UpdateThread..."文字,且自动换行26 //textview的append功能和Qt中的append类似，不会覆盖前面27 //的内容，只是Qt中的append默认是自动换行模式

28 text_view.append("\nUpdateThread...");29 //延时1s后又将线程加入到线程队列中

30 handler.postDelayed(update_thread, 1000);31

32 }33 };34

35 @Override36 public voidonCreate(Bundle savedInstanceState) {37 super.onCreate(savedInstanceState);38 setContentView(R.layout.activity_main);39

40 text_view =(TextView)findViewById(R.id.text_view);41 start =(Button)findViewById(R.id.start);42 start.setOnClickListener(newStartClickListener());43 end =(Button)findViewById(R.id.end);44 end.setOnClickListener(newEndClickListener());45

46 }47

48 private class StartClickListener implementsOnClickListener49 {50 public voidonClick(View v) {51 //TODO Auto-generated method stub52 //将线程接口立刻送到线程队列中

53 handler.post(update_thread);54 }55 }56

57 private class EndClickListener implementsOnClickListener58 {59

60 public voidonClick(View v) {61 //TODO Auto-generated method stub62 //将接口从线程队列中移除

63 handler.removeCallbacks(update_thread);64 }65

66 }67

68 @Override69 public booleanonCreateOptionsMenu(Menu menu) {70 getMenuInflater().inflate(R.menu.activity_main, menu);71 return true;72 }73 }

activity_main.xml:

1

2 xmlns:tools="http://schemas.android.com/tools"

3 android:layout_width="match_parent"

4 android:layout_height="match_parent"

5 android:orientation="vertical" >

6

7

8

10 android:layout_width="fill_parent"

11 android:layout_height="200dip"

12 android:text="@string/hello_world"

13 tools:context=".MainActivity" />

14

16 android:layout_width="fill_parent"

17 android:layout_height="wrap_content"

18 android:text="@string/start"

19 />

20

22 android:layout_width="fill_parent"

23 android:layout_height="wrap_content"

24 android:text="@string/end"

25 />

26

27

Handler使用例2这个例子比刚才那个例子稍微复杂些。因为这个例子中用到了handler的消息队列机制，即通过handler中一个线程向消息队列中用sendMessage方法发送消息，发送的消息当然可以用来传递参数。在handler中用handleMessage来处理消息，处理方法是获得消息队列中的消息参数，用这些参数来完成另外一些功能。

本实验实现的是当开始按钮按下时，会启动一个线程，并绑定到handler中，该线程发送带有参数的message到handler的消息队列中，消息队列的另一端获取该消息，并且用该消息的参数来更新进度条。

软件打开后：

单击Start按钮后，更新的进度条结果如下(怎么感觉4.1版本android进度条那么小呢？不懂该怎么设置)：

实验主要部分代码和注释：

MainActivity.java:

1 packagecom.example.handler2;2 importandroid.app.Activity;3 importandroid.os.Bundle;4 importandroid.os.Handler;5 importandroid.os.Message;6 importandroid.view.Menu;7 importandroid.view.View;8 importandroid.view.View.OnClickListener;9 importandroid.widget.Button;10 importandroid.widget.ProgressBar;11

12 public class MainActivity extendsActivity {13

14 private ProgressBar progress_bar = null;15 private Button start = null;16

17 @Override18 public voidonCreate(Bundle savedInstanceState) {19 super.onCreate(savedInstanceState);20 setContentView(R.layout.activity_main);21 progress_bar =(ProgressBar)findViewById(R.id.progress_bar);22 start =(Button)findViewById(R.id.start);23

24 start.setOnClickListener(newStartOnClickListenr());25 }26

27 private class StartOnClickListenr implementsOnClickListener28 {29 public voidonClick(View v) {30 //TODO Auto-generated method stub31 //让进度条显示出来

32 progress_bar.setVisibility(View.VISIBLE);33 //将线程加入到handler的线程队列中

34 update_progress_bar.post(update_thread);35

36 }37 }38

39 //创建一个handler，内部完成处理消息方法

40 Handler update_progress_bar = newHandler()41 {42 @Override43 public voidhandleMessage(Message msg) {44 //TODO Auto-generated method stub45 //super.handleMessage(msg);46 //显示进度条

47 progress_bar.setProgress(msg.arg1);48 //重新把进程加入到进程队列中

49 update_progress_bar.post(update_thread);50 }51 };//不加这个分号则不能自动添加代码

52

53 Runnable update_thread = newRunnable()54 {55 int i = 0;56 public voidrun() {57 //TODO Auto-generated method stub

58 i += 10;59 //首先获得一个消息结构

60 Message msg =update_progress_bar.obtainMessage();61 //给消息结构的arg1参数赋值

62 msg.arg1 =i;63 //延时1s，java中的try+catch用来排错处理

64 try{65 Thread.sleep(1000);66 } catch(InterruptedException e) {67 //TODO: handle exception

68 e.printStackTrace();69 }70 //把消息发送到消息队列中

71 update_progress_bar.sendMessage(msg);72 if(i == 100)73 //把线程从线程队列中移除

74 update_progress_bar.removeCallbacks(update_thread);75 }76 };77

78 @Override79 public booleanonCreateOptionsMenu(Menu menu) {80 getMenuInflater().inflate(R.menu.activity_main, menu);81 return true;82 }83 }

activity_main.xml:

1

2 xmlns:tools="http://schemas.android.com/tools"

3 android:layout_width="match_parent"

4 android:layout_height="match_parent" >

5

7 android:layout_width="fill_parent"

8 android:layout_height="wrap_content"

9 android:layout_alignParentBottom="true"

10 android:text="@string/start"

11 />

12

14 android:layout_width="fill_parent"

15 android:layout_height="100dip"

16 android:layout_alignParentTop="true"

17 style="?android:attr/progressBarStyleHorizontal"

18 android:visibility="gone"

19 />

20

21

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:

1 packagecom.example.handler3;2 importandroid.app.Activity;3 importandroid.os.Bundle;4 importandroid.os.Handler;5 importandroid.view.Menu;6

7 public class MainActivity extendsActivity {8

9 //新建一个handler

10 private Handler handler = newHandler();11 @Override12 public voidonCreate(Bundle savedInstanceState) {13 super.onCreate(savedInstanceState);14

15 //将runnable加载到handler的线程队列中去16 //handler.post(r);

17 Thread t = newThread(r);18 t.start();19 setContentView(R.layout.activity_main);20 //打印activtiy线程信息

21 System.out.println("activity_id---->"+Thread.currentThread().getId());22 System.out.println("activity_name---->"+Thread.currentThread().getName());23 }24

25 Runnable r = newRunnable()26 {27 public voidrun() {28 //TODO Auto-generated method stub29 //打印新建线程信息

30 System.out.println("handler_id---->"+Thread.currentThread().getId());31 System.out.println("handler_name---->"+Thread.currentThread().getName());32 //延时10s，为了观察主界面中内容出现的时间

33 try{34 Thread.sleep(10000);35 } catch(InterruptedException e) {36 //TODO: handle exception

37 e.printStackTrace();38 }39 }40

41 };42

43 @Override44 public booleanonCreateOptionsMenu(Menu menu) {45 getMenuInflater().inflate(R.menu.activity_main, menu);46 return true;47 }48 }

如果把语句：

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:

1 packagecom.example.handler4;2

3

4 importandroid.app.Activity;5 importandroid.os.Bundle;6 importandroid.os.Handler;7 importandroid.os.HandlerThread;8 importandroid.os.Looper;9 importandroid.os.Message;10 importandroid.view.Menu;11

12 public class MainActivity extendsActivity {13

14 @Override15 public voidonCreate(Bundle savedInstanceState) {16 super.onCreate(savedInstanceState);17 setContentView(R.layout.activity_main);18

19 System.out.println("activity_ID---->"+Thread.currentThread().getId());20 //新建一个HanderThread对象，该对象实现了用Looper来处理消息队列的功能

21 HandlerThread handler_thread = new HandlerThread("handler_thread");22 handler_thread.start();23 //MyHandler类是自己继承的一个类，这里采用hand_thread的Looper来初始化它

24 MyHandler my_handler = newMyHandler(handler_thread.getLooper());25 //获得一个消息msg

26 Message msg =my_handler.obtainMessage();27

28 //采用Bundle保存数据，Bundle中存放的是键值对的map，只是它的键值类型和数据类型比较固定而已

29 Bundle b = newBundle();30 b.putString("whether", "晴天");31 b.putInt("temperature", 34);32 msg.setData(b);33 //将msg发送到自己的handler中，这里指的是my_handler,调用该handler的HandleMessage方法来处理该mug

34 msg.sendToTarget();35 }36

37 class MyHandler extendsHandler38 {39 //空的构造函数

40 publicMyHandler()41 {}42 //以Looper类型参数传递的函数，Looper为消息泵，不断循环的从消息队列中得到消息并处理，因此43 //每个消息队列都有一个Looper，因为Looper是已经封装好了的消息队列和消息循环的类

44 publicMyHandler(Looper looper)45 {46 //调用父类的构造函数

47 super(looper);48 }49 @Override50 public voidhandleMessage(Message msg) {51 //TODO Auto-generated method stub

52 System.out.println("Handler_ID---->"+Thread.currentThread().getId());53 System.out.println("Handler_Name---->"+Thread.currentThread().getId());54 //将消息中的bundle数据取出来

55 Bundle b =msg.getData();56 String whether = b.getString("whether");57 int temperature = b.getInt("temperature");58 System.out.println("whether= "+whether+" ,temperature= "+temperature);59 }60

61 }62

63 @Override64 public booleanonCreateOptionsMenu(Menu menu) {65 getMenuInflater().inflate(R.menu.activity_main, menu);66 return true;67 }68 }

总结：

Android中的handler可以用来完成异步的消息出来，即发送消息和接收消息相互独立，可以同时运行。在例1和例2中，实际上handler中使用的线程是与它所在的activity处于同一个主线程，因为handler中调用的runnable接口是直接运行该接口的run函数的，而不是start函数。例3专门比较了这2中情况。例4学会使用怎样在新线程中处理消息的方法。

开发环境为android4.1