Android Handler详细介绍+示例

本文主要介绍Android中Handler的使用方法，Handler跟多线程，消息队列联系很紧密，在平常的实际程序开发中比较常见。本文分为4个简单的例子。

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

MainActivity.java

[java] view plain copy print ?

1. package com.example.handler1;    
2.  import android.app.Activity;  
3. import android.os.Bundle;  
4. import android.os.Handler;  
5. import android.view.Menu;  
6. import android.view.View;  
7. import android.view.View.OnClickListener;  
8. import android.widget.Button;  
9. import android.widget.TextView;   
10.  public class MainActivity extends Activity {   
11.      private TextView text_view = null;  
12.     private Button start = null;  
13.     private Button end = null;  
14.   
15.     //使用handler时首先要创建一个handler  
16.     Handler handler = new Handler();  
17.     //要用handler来处理多线程可以使用runnable接口，这里先定义该接口  
18.     //线程中运行该接口的run函数  
19.     Runnable update_thread = new Runnable()  
20.     {  
21.         public void run()  
22.         {  
23.             //线程每次执行时输出"UpdateThread..."文字,且自动换行  
24.             //textview的append功能和Qt中的append类似，不会覆盖前面  
25.             //的内容，只是Qt中的append默认是自动换行模式  
26.             text_view.append("\nUpdateThread...");  
27.             //延时1s后又将线程加入到线程队列中  
28.             handler.postDelayed(update_thread, 1000);  
29.   
30.         }  
31.     };  
32.   
33.     @Override  
34.     public void onCreate(Bundle savedInstanceState) {  
35.         super.onCreate(savedInstanceState);  
36.         setContentView(R.layout.activity_main);  
37.   
38.         text_view = (TextView)findViewById(R.id.text_view);  
39.         start = (Button)findViewById(R.id.start);  
40.         start.setOnClickListener(new StartClickListener());  
41.         end = (Button)findViewById(R.id.end);  
42.         end.setOnClickListener(new EndClickListener());  
43.   
44.     }   
45.      private class StartClickListener implements OnClickListener  
46.     {  
47.         public void onClick(View v) {  
48.             // TODO Auto-generated method stub  
49.             //将线程接口立刻送到线程队列中  
50.             handler.post(update_thread);  
51.         }                  
52.     }  
53.   
54.     private class EndClickListener implements OnClickListener  
55.     {   
56.          public void onClick(View v) {  
57.             // TODO Auto-generated method stub  
58.             //将接口从线程队列中移除  
59.             handler.removeCallbacks(update_thread);  
60.         }  
61.   
62.     }  
63.   
64.     @Override  
65.     public boolean onCreateOptionsMenu(Menu menu) {  
66.         getMenuInflater().inflate(R.menu.activity_main, menu);  
67.         return true;  
68.     }  
69. }  
70.    

activity_main.xml

[html] view plain copy print ?

1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
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.      <TextView  
7.         android:id="@+id/text_view"  
8.         android:layout_width="fill_parent"  
9.         android:layout_height="200dip"  
10.         android:text="@string/hello_world"  
11.         tools:context=".MainActivity" />  
12.     <Button   
13.         android:id="@+id/start"  
14.         android:layout_width="fill_parent"  
15.         android:layout_height="wrap_content"  
16.         android:text="@string/start"  
17.         />  
18.     <Button   
19.         android:id="@+id/end"  
20.         android:layout_width="fill_parent"  
21.         android:layout_height="wrap_content"  
22.         android:text="@string/end"  
23.         />   
24.  </LinearLayout>  
25.     

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

MainActivity.java

[java] view plain copy print ?

1. package com.example.handler2;    
2.  import android.app.Activity;  
3. import android.os.Bundle;  
4. import android.os.Handler;  
5. import android.os.Message;  
6. import android.view.Menu;  
7. import android.view.View;  
8. import android.view.View.OnClickListener;  
9. import android.widget.Button;  
10. import android.widget.ProgressBar;  
11.  public class MainActivity extends Activity {  
12.      private ProgressBar progress_bar = null;  
13.     private Button start = null;  
14.   
15.     @Override  
16.     public void onCreate(Bundle savedInstanceState) {  
17.         super.onCreate(savedInstanceState);  
18.         setContentView(R.layout.activity_main);  
19.         progress_bar = (ProgressBar)findViewById(R.id.progress_bar);  
20.         start = (Button)findViewById(R.id.start);  
21.   
22.         start.setOnClickListener(new StartOnClickListenr());  
23.     }  
24.   
25.     private class StartOnClickListenr implements OnClickListener  
26.     {  
27.         public void onClick(View v) {  
28.             // TODO Auto-generated method stub  
29.             //让进度条显示出来  
30.             progress_bar.setVisibility(View.VISIBLE);  
31.             //将线程加入到handler的线程队列中  
32.             update_progress_bar.post(update_thread);  
33.   
34.         }  
35.     }  
36.      //创建一个handler，内部完成处理消息方法  
37.     Handler update_progress_bar = new Handler()  
38.     {  
39.         @Override  
40.         public void handleMessage(Message msg) {  
41.             // TODO Auto-generated method stub  
42.             //super.handleMessage(msg);  
43.             //显示进度条  
44.             progress_bar.setProgress(msg.arg1);  
45.             //重新把进程加入到进程队列中  
46.             update_progress_bar.post(update_thread);  
47.         }         
48.     };//不加这个分号则不能自动添加代码  
49.   
50.     Runnable update_thread = new Runnable()  
51.     {  
52.         int i = 0;  
53.         public void run() {  
54.             // TODO Auto-generated method stub  
55.             i += 10;  
56.             //首先获得一个消息结构  
57.             Message msg = update_progress_bar.obtainMessage();  
58.             //给消息结构的arg1参数赋值  
59.             msg.arg1 = i;  
60.             //延时1s，java中的try+catch用来排错处理  
61.             try {  
62.                 Thread.sleep(1000);  
63.             } catch (InterruptedException e) {  
64.                 // TODO: handle exception  
65.                 e.printStackTrace();  
66.             }  
67.             //把消息发送到消息队列中  
68.             update_progress_bar.sendMessage(msg);  
69.             if(i == 100)  
70.                 //把线程从线程队列中移除  
71.                 update_progress_bar.removeCallbacks(update_thread);  
72.         }         
73.     };  
74.   
75.     @Override  
76.     public boolean onCreateOptionsMenu(Menu menu) {  
77.         getMenuInflater().inflate(R.menu.activity_main, menu);  
78.         return true;  
79.     }  
80. }  

activity_main.xml

[html] view plain copy print ?

1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     xmlns:tools="http://schemas.android.com/tools"  
3.     android:layout_width="match_parent"  
4.     android:layout_height="match_parent" >    
5.      <Button   
6.         android:id="@+id/start"  
7.         android:layout_width="fill_parent"  
8.         android:layout_height="wrap_content"  
9.         android:layout_alignParentBottom="true"  
10.         android:text="@string/start"  
11.         />  
12.     <ProgressBar   
13.         android:id="@+id/progress_bar"  
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.  </RelativeLayout>  
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

[java] view plain copy print ?

1. package com.example.handler3;    
2.  import android.app.Activity;  
3. import android.os.Bundle;  
4. import android.os.Handler;  
5. import android.view.Menu;   
6.  public class MainActivity extends Activity {   
7.      //新建一个handler  
8.     private Handler handler = new Handler();  
9.     @Override  
10.     public void onCreate(Bundle savedInstanceState) {  
11.         super.onCreate(savedInstanceState);  
12.   
13.         //将runnable加载到handler的线程队列中去  
14.       //  handler.post(r);          
15.         Thread t = new Thread(r);  
16.         t.start();  
17.         setContentView(R.layout.activity_main);  
18.         //打印activtiy线程信息  
19.         System.out.println("activity_id---->"+Thread.currentThread().getId());  
20.         System.out.println("activity_name---->"+Thread.currentThread().getName());  
21.     }   
22.      Runnable r = new Runnable()  
23.     {  
24.         public void run() {  
25.             // TODO Auto-generated method stub  
26.             //打印新建线程信息  
27.             System.out.println("handler_id---->"+Thread.currentThread().getId());  
28.             System.out.println("handler_name---->"+Thread.currentThread().getName());  
29.             //延时10s，为了观察主界面中内容出现的时间  
30.             try {  
31.                 Thread.sleep(10000);  
32.             } catch (InterruptedException e) {  
33.                 // TODO: handle exception  
34.                 e.printStackTrace();  
35.             }  
36.         }  
37.   
38.     };  
39.   
40.     @Override  
41.     public boolean onCreateOptionsMenu(Menu menu) {  
42.         getMenuInflater().inflate(R.menu.activity_main, menu);  
43.         return true;  
44.     }  
45. }  
46.    

如果把语句：
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

[java] view plain copy print ?

1. package com.example.handler4;    
2.  import android.app.Activity;  
3. import android.os.Bundle;  
4. import android.os.Handler;  
5. import android.os.HandlerThread;  
6. import android.os.Looper;  
7. import android.os.Message;  
8. import android.view.Menu;   
9.  public class MainActivity extends Activity {   
10.      @Override  
11.     public void onCreate(Bundle savedInstanceState) {  
12.         super.onCreate(savedInstanceState);  
13.         setContentView(R.layout.activity_main);  
14.   
15.         System.out.println("activity_ID---->"+Thread.currentThread().getId());  
16.         //新建一个HanderThread对象，该对象实现了用Looper来处理消息队列的功能  
17.         HandlerThread handler_thread = new HandlerThread("handler_thread");  
18.         handler_thread.start();  
19.         //MyHandler类是自己继承的一个类，这里采用hand_thread的Looper来初始化它  
20.         MyHandler my_handler = new MyHandler(handler_thread.getLooper());  
21.         //获得一个消息msg  
22.         Message msg = my_handler.obtainMessage();  
23.   
24.         //采用Bundle保存数据，Bundle中存放的是键值对的map，只是它的键值类型和数据类型比较固定而已  
25.         Bundle b = new Bundle();  
26.         b.putString("whether", "晴天");  
27.         b.putInt("temperature", 34);  
28.         msg.setData(b);  
29.       //将msg发送到自己的handler中，这里指的是my_handler,调用该handler的HandleMessage方法来处理该mug  
30.         msg.sendToTarget();  
31.     }   
32.      class MyHandler extends Handler  
33.     {  
34.         //空的构造函数  
35.         public MyHandler()  
36.         {}  
37.         //以Looper类型参数传递的函数，Looper为消息泵，不断循环的从消息队列中得到消息并处理，因此  
38.         //每个消息队列都有一个Looper，因为Looper是已经封装好了的消息队列和消息循环的类  
39.         public MyHandler(Looper looper)  
40.         {  
41.             //调用父类的构造函数  
42.             super(looper);  
43.         }  
44.         @Override  
45.         public void handleMessage(Message msg) {  
46.             // TODO Auto-generated method stub  
47.             System.out.println("Handler_ID---->"+Thread.currentThread().getId());  
48.             System.out.println("Handler_Name---->"+Thread.currentThread().getId());  
49.             //将消息中的bundle数据取出来  
50.             Bundle b = msg.getData();  
51.             String whether = b.getString("whether");  
52.             int temperature = b.getInt("temperature");  
53.             System.out.println("whether= "+whether+" ,temperature= "+temperature);  
54.         }  
55.   
56.     }  
57.   
58.     @Override  
59.     public boolean onCreateOptionsMenu(Menu menu) {  
60.         getMenuInflater().inflate(R.menu.activity_main, menu);  
61.         return true;  
62.     }  
63. }  
64.    

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

• 上一篇Android之Message,MessageQueue,Looper,Handler详解（带示例）

顶

1

踩

0

主题推荐

android relativelayout 程序开发 exception 多线程

猜你在找

Android之MessageMessageQueueLooperHandler详解带示例

android 多线程ThreadRunnableHandlerAsyncTask等之间的关系

android示例之HandlerThread和Handler简介

android 多线程之Handler和Message未完成

Android 开发之多线程处理Handler 详解

Android--多线程之Handler

Android--多线程之Handler

Android多线程HandlerLooper消息队列

Android多线程之图解Handler Looper MessageQueue Message

Android 多线程工具HandlerAsyncTask总结

查看评论

  暂无评论

发表评论