Android之Handler用法总结
来源:互联网 发布:阿里巴巴有淘宝客吗 编辑:程序博客网 时间:2024/06/03 17:14
对于从事过J2ME开发的程序员来说Thread比较简单,直接匿名创建重写run方法,调用start方法执行即可。或者从Runnable接口继承,但对于Android平台来说UI控件都没有设计成为线程安全类型,所以需要引入一些同步的机制来使其刷新,这点Google在设计Android时倒是参考了下Win32的消息处理机制。
1. 对于线程中的刷新一个View为基类的界面,可以使用postInvalidate()方法在线程中来处理,其中还提供了一些重写方法比如postInvalidate(int left,int top,int right,int bottom) 来刷新一个矩形区域,以及延时执行,比如postInvalidateDelayed(long delayMilliseconds)或postInvalidateDelayed(long delayMilliseconds,int left,int top,int right,int bottom) 方法,其中第一个参数为毫秒
2. 当然推荐的方法是通过一个Handler来处理这些,可以在一个线程的run方法中调用handler对象的 postMessage或sendMessage方法来实现,Android程序内部维护着一个消息队列,会轮训处理这些,如果你是Win32程序员可以很好理解这些消息处理,不过相对于Android来说没有提供 PreTranslateMessage这些干涉内部的方法。
3. Looper又是什么呢? ,其实Android中每一个Thread都跟着一个Looper,Looper可以帮助Thread维护一个消息队列,但是Looper和Handler没有什么关系,我们从开源的代码可以看到Android还提供了一个Thread继承类HanderThread可以帮助我们处理,在HandlerThread对象中可以通过getLooper方法获取一个Looper对象控制句柄,我们可以将其这个Looper对象映射到一个Handler中去来实现一个线程同步机制,Looper对象的执行需要初始化Looper.prepare方法就是昨天我们看到的问题,同时推出时还要释放资源,使用Looper.release方法。
4.Message 在Android是什么呢? 对于Android中Handler可以传递一些内容,通过Bundle对象可以封装String、Integer以及Blob二进制对象,我们通过在线程中使用Handler对象的sendEmptyMessage或sendMessage方法来传递一个Bundle对象到Handler处理器。对于Handler类提供了重写方法handleMessage(Message msg) 来判断,通过msg.what来区分每条信息。将Bundle解包来实现Handler类更新UI线程中的内容实现控件的刷新操作。相关的Handler对象有关消息发送sendXXXX相关方法如下,同时还有postXXXX相关方法,这些和Win32中的道理基本一致,一个为发送后直接返回,一个为处理后才返回 .
5. java.util.concurrent对象分析,对于过去从事Java开发的程序员不会对Concurrent对象感到陌生吧,他是JDK 1.5以后新增的重要特性作为掌上设备,我们不提倡使用该类,考虑到Android为我们已经设计好的Task机制,这里不做过多的赘述,相关原因参考下面的介绍:
6. 在Android中还提供了一种有别于线程的处理方式,就是Task以及AsyncTask,从开源代码中可以看到是针对Concurrent的封装,开发人员可以方便的处理这些异步任务。
Handler使用例1
- public class MyHandlerActivity extends Activity {
- Button button;
- MyHandler myHandler;
- protected void onCreate(Bundle savedInstanceState) {
- super。onCreate(savedInstanceState);
- setContentView(R。layout。handlertest);
- button = (Button) findViewById(R。id。button);
- myHandler = new MyHandler();
- // 当创建一个新的Handler实例时, 它会绑定到当前线程和消息的队列中,开始分发数据
- // Handler有两个作用, (1) : 定时执行Message和Runnalbe 对象
- // (2): 让一个动作,在不同的线程中执行。
- // 它安排消息,用以下方法
- // post(Runnable)
- // postAtTime(Runnable,long)
- // postDelayed(Runnable,long)
- // sendEmptyMessage(int)
- // sendMessage(Message);
- // sendMessageAtTime(Message,long)
- // sendMessageDelayed(Message,long)
- // 以上方法以 post开头的允许你处理Runnable对象
- //sendMessage()允许你处理Message对象(Message里可以包含数据,)
- MyThread m = new MyThread();
- new Thread(m)。start();
- }
- /**
- * 接受消息,处理消息 ,此Handler会与当前主线程一块运行
- * */
- class MyHandler extends Handler {
- public MyHandler() {
- }
- public MyHandler(Looper L) {
- super(L);
- }
- // 子类必须重写此方法,接受数据
- @Override
- public void handleMessage(Message msg) {
- // TODO Auto-generated method stub
- Log。d("MyHandler", "handleMessage。。。。。。");
- super。handleMessage(msg);
- // 此处可以更新UI
- Bundle b = msg。getData();
- String color = b。getString("color");
- MyHandlerActivity。this。button。append(color);
- }
- }
- class MyThread implements Runnable {
- public void run() {
- try {
- Thread。sleep(10000);
- } catch (InterruptedException e) {
- // TODO Auto-generated catch block
- e。printStackTrace();
- }
- Log。d("thread。。。。。。。", "mThread。。。。。。。。");
- Message msg = new Message();
- Bundle b = new Bundle();// 存放数据
- b。putString("color", "我的");
- msg。setData(b);
- MyHandlerActivity。this。myHandler。sendMessage(msg); // 向Handler发送消息,更新UI
- }
- }
- }
这个例子是最简单的介绍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学会使用怎样在新线程中处理消息的方法。
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- Android之Handler用法总结
- 程序员必会dll依赖神器-Dependency Walker
- 2016年推动云计算全面爆发的三大关键性趋势
- RESTful的理解
- 圣诞来了,喜欢她就去表白吧,要不然她怎么有机会拒绝你呢?
- Redis常用命令
- Android之Handler用法总结
- android-Copy and Paste(text and input)
- Activity生命周期
- Java Executor 框架学习总结
- Arrange an Array to Form a Smallest Digit
- Spark 学习视频汇总
- 【c/c++】delete和delete[]详解
- mysql 版本
- Win7系统怀疑重启