Android中Handler的使用方法及实例（基础回顾）

Handler使用例1

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

软件界面如下：

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

MainActivity.java:

 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
11 public class MainActivity extends Activity {
12
13     private TextView text_view = null;
14     private Button start = null;
15     private Button end = null;
16
17     //使用handler时首先要创建一个handler
18     Handler handler = new Handler();
19     //要用handler来处理多线程可以使用runnable接口，这里先定义该接口
20     //线程中运行该接口的run函数
21     Runnable update_thread = new Runnable()
22     {
23         public void run()
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     @Override
36     public void onCreate(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(new StartClickListener());
43         end = (Button)findViewById(R.id.end);
44         end.setOnClickListener(new EndClickListener());
45
46     }
47
48     private class StartClickListener implements OnClickListener
49     {
50         public void onClick(View v) {
51             // TODO Auto-generated method stub
52             //将线程接口立刻送到线程队列中
53             handler.post(update_thread);
54         }
55     }
56
57     private class EndClickListener implements OnClickListener
58     {
59
60         public void onClick(View v) {
61             // TODO Auto-generated method stub
62             //将接口从线程队列中移除
63             handler.removeCallbacks(update_thread);
64         }
65
66     }
67
68     @Override
69     public boolean onCreateOptionsMenu(Menu menu) {
70         getMenuInflater().inflate(R.menu.activity_main, menu);
71         return true;
72     }
73 }

activity_main.xml:

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

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

软件打开后：


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

实验主要部分代码和注释：
MainActivity.java:

 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
12 public class MainActivity extends Activity {
13
14     private ProgressBar progress_bar = null;
15     private Button start = null;
16
17     @Override
18     public void onCreate(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(new StartOnClickListenr());
25     }
26
27     private class StartOnClickListenr implements OnClickListener
28     {
29         public void onClick(View v) {
30             // TODO Auto-generated method stub
31             //让进度条显示出来
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 = new Handler()
41     {
42         @Override
43         public void handleMessage(Message msg) {
44             // TODO Auto-generated method stub
45             //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 = new Runnable()
54     {
55         int i = 0;
56         public void run() {
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     @Override
79     public boolean onCreateOptionsMenu(Menu menu) {
80         getMenuInflater().inflate(R.menu.activity_main, menu);
81         return true;
82     }
83 }

activity_main.xml:

 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
21 </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:

 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
 7 public class MainActivity extends Activity {
 8
 9     //新建一个handler
10     private Handler handler = new Handler();
11     @Override
12     public void onCreate(Bundle savedInstanceState) {
13         super.onCreate(savedInstanceState);
14
15         //将runnable加载到handler的线程队列中去
16       //  handler.post(r);
17         Thread t = new Thread(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 = new Runnable()
26     {
27         public void run() {
28             // TODO Auto-generated method stub
29             //打印新建线程信息
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     @Override
44     public boolean onCreateOptionsMenu(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 package com.example.handler4;
 2
 3
 4 import android.app.Activity;
 5 import android.os.Bundle;
 6 import android.os.Handler;
 7 import android.os.HandlerThread;
 8 import android.os.Looper;
 9 import android.os.Message;
10 import android.view.Menu;
11
12 public class MainActivity extends Activity {
13
14     @Override
15     public void onCreate(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 = new MyHandler(handler_thread.getLooper());
25         //获得一个消息msg
26         Message msg = my_handler.obtainMessage();
27
28         //采用Bundle保存数据，Bundle中存放的是键值对的map，只是它的键值类型和数据类型比较固定而已
29         Bundle b = new Bundle();
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 extends Handler
38     {
39         //空的构造函数
40         public MyHandler()
41         {}
42         //以Looper类型参数传递的函数，Looper为消息泵，不断循环的从消息队列中得到消息并处理，因此
43         //每个消息队列都有一个Looper，因为Looper是已经封装好了的消息队列和消息循环的类
44         public MyHandler(Looper looper)
45         {
46             //调用父类的构造函数
47             super(looper);
48         }
49         @Override
50         public void handleMessage(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     @Override
64     public boolean onCreateOptionsMenu(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

时间： 2024-10-08 07:35:36

Android中Handler的使用方法及实例（基础回顾）的相关文章

Android中Handler的使用方法——在子线程中更新界面

本文主要介绍Android的Handler的使用方法.Handler可以发送Messsage和Runnable对象到与其相关联的线程的消息队列.每个Handler对象与创建它的线程相关联,并且每个Handler对象只能与一个线程相关联. Handler一般有两种用途:1)执行计划任务,你可以再预定的实现执行某些任务,可以模拟定时器.2)线程间通信.在Android的应用启动时,会创建一个主线程,主线程会创建一个消息队列来处理各种消息.当你创建子线程时,你可以再你的子线程中拿到父线程中创建的Han

Android中Handler 、Thread和Runnable之间的关系

在多线程编程的时候,我们经常会用到Handler,Thread和Runnable这三个类,我们来看看这三个类之间是怎么样的关系? 首先说明Android的CPU分配的最小单元是线程,Handler一般是在某个线程里创建的,因而Handler和Thread就是相互绑定的,一一对应. 而Runnable是一个接口,Thread是Runnable的子类.可以说,他俩都算一个进程. HandlerThread顾名思义就是可以处理消息循环的线程,他是一个拥有Looper的线程,可以处理消息循环. 与其说H

深入解析Android中Handler消息机制

Android提供了Handler 和 Looper 来满足线程间的通信.Handler先进先出原则.Looper类用来管理特定线程内对象之间的消息交换(MessageExchange).Handler消息机制可以说是Android系统中最重要部分之一,所以,本篇博客我们就来深入解析Android中Handler消息机制. Handler的简单使用 为什么系统不允许子线程更新UI 因为的UI控件不是线程安全的. 如果在多线程中并发访问可能会导致UI控件处于不可预期的状态,那为什么不对UI控件的访

Android中Handler Runnable与Thread的区别详解

原文链接:http://www.codeceo.com/article/android-handler-runnable-thread.html Android中Handler可以异步控制Runnable,那么这样做于Android中的Thread有什么区别呢?本文将通过多个角度来讲解这个问题,读完此文,相信你会对Android中的Handler Runnable与Thread有一个非常全面的了解. 在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口:T

Android中制作自定义dialog对话框的实例

http://www.jb51.net/article/83319.htm 这篇文章主要介绍了Android中制作自定义dialog对话框的实例分享,安卓自带的Dialog显然不够用,因而我们要继承Dialog类来制作自己的对话框,需要的朋友可以参考下 自定义dialog基础版很多时候,我们在使用android sdk提供的alerdialog的时候,会因为你的系统的不同而产生不同的效果,就好比如你刷的是MIUI的系统,弹出框都会在顶部显示!这里简单的介绍自定义弹出框的应用. 首先创建布局文件d

异步消息处理机制-Android中Handler原理(续)

异步消息处理线程是指线程启动后会进入一个无限循环,每循环一次,从内部的消息队列里面取出一个消息,并回调相应的消息处理函数.一般在任务常驻,比如用户交互任务的情况下使用异步消息处理线程. 之前在Android中Handler原理里面研究过android里实现异步消息处理线程的方式,基本逻辑如图所示 今天就用java将其简单的模拟出来加深印象,下面的类图是用工具导出的,不太正规,不过能大概看出类之间的关系 Message类:消息类 public class Message { public int

虚方法和抽象方法--基础回顾

抽象方法是只有定义.没有实际方法体的函数,它只能在抽象函数中出现,并且在子类中必须重写:虚方法则有自己的函数体,已经提供了函数实现,但是允许在子类中重写或覆盖.重写的子类虚函数就是被覆盖了. 抽象方法 使用abstract关键字 public abstract bool Withdraw(…); 抽象方法是必须被派生类覆写的方法. 抽象方法是可以看成是没有实现体的虚方法 如果类中包含抽象方法,那么类就必须定义为抽象类,不论是否还包含其它一般方法 虚方法 使用virtual关键字 public v

Android中Handler引起的内存泄露

在Android常用编程中,Handler在进行异步操作并处理返回结果时经常被使用.通常我们的代码会这样实现. 但是,其实上面的代码可能导致内存泄露,当你使用Android lint工具的话,会得到这样的警告 In Android, Handler classes should be static or leaks might occur, Messages enqueued on the application thread’s MessageQueue also retain their t

[转]Android中handler总结

一.Handler的定义: Handler主要接收子线程发送的数据, 并用此数据配合主线程更新UI,用来跟UI主线程交互用.比如可以用handler发送一个message,然后在handler的线程中来接收.处理该消息,以避免直接在UI主线程中处理事务导致影响UI主线程的其他处理工作,Android提供了Handler作为主线程和子线程的纽带:也可以将handler对象传给其他进程,以便在其他进程中通过handler给你发送事件:还可以通过handler的延时发送message,可以延时处理一些