Handle----Thread-----Runnable------使用的几种情况

最新推荐文章于 2025-11-28 14:55:35 发布

原创最新推荐文章于 2025-11-28 14:55:35 发布 · 9.9k 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#android #thread #listview #exception #dialog #ui

android开发专栏收录该内容

14 篇文章

订阅专栏

本文详细介绍了Android中Handler、Thread和Runnable的使用，包括它们各自的作用和如何结合使用来处理消息、更新UI。Handler主要用于发送和接收消息，包括post和sendMessage方法。使用Handler可以避免主线程因处理长时间任务而引发的ANP错误。文章还提到了HandlerThread和如何通过Handler更新UI，以及使用Runnable进行定时UI更新。此外，文章还简要讨论了Java并发库和Android的Task、AsyncTask机制。

参考网址：

http://www.cnblogs.com/playing/archive/2011/03/24/1993583.html

1、基础知识

Handler在android系统中，主要负责发送和接收消息，它的用途主要有以下两种：

（1）按照计划来处理一个消息（sendMessage(Message)方法）或者执行某个runnable实例（post(Runnable)方法）

（2）把其他的线程对象放入消息队列中，避免线程冲突。

消息的发送通过post(Runnable), postAtTime(Runnable, long), postDelayed(Runnable, long), sendEmptyMessage(int),sendMessage(Message), sendMessageAtTime(Message, long)和 sendMessageDelayed(Message, long) 方法完成。对于postXXX方法通过Runnable对象给消息队列，并在消息队列到达后被调用。对于sendMessageXXX方法，则传递一个包含message对象，该对象可以被Handler类的handlerMessage（Message）方法处理。

2.为什么要使用Handler：

因为,我们当我们的主线程队列,如果处理一个消息超过5秒,android 就会抛出一个 ANP(无响应)的消息,所以,我们需要把一些要处理比较长的消息,放在一个单独线程里面处理,把处理以后的结果,返回给主线程运行,就需要用的Handler来进行线程建的通信,可以说它是Runnable和Activity交互的桥梁

Handle有两类发送消息的方式：

一类是postXXX()方法，该方法把一个Runnable对象发送到消息队列，从而当消息被处理时，能够执行Runnable对象；

另一类是sendXXX()方法，该方法用于发送一个Message类型的消息到消息队列，当消息被处理时，系统会调用Handler对象定义的handleMessage()方法处理该消息。如果通过工作线程刷新界面，推荐使用handler对象来实现

3.Handler+Thread来更新UI:

HandlerThread类来创建独立于主线程的新线程，实现异步机制，不会影响到主线程的运行,Handler来根据接收的消息，处理UI更新。Thread线程发出Handler消息，通知更新UI。

(1)Handler类根据消息来更新UI

public Handler myHandler = new Handler(){
@Override
public void handleMessage(Message msg) {//重写的方法用于接收Handler消息
	super.handleMessage(msg);
	if(msg.what == 1 || msg.what == 2 ||msg.what == 3){//得到美食搜索结果
		Bundle data = msg.getData();
		mstxInfos = (ArrayList)data.get("mstxInfo");
		mstxImages = (ArrayList)data.get("mstxImages");
		//为ListView准备内容适配器
		MyBaseAdapter mba = new MyBaseAdapter(mstxInfos,mstxImages);
		lv.setAdapter(mba);//为ListView设置内容适配器	
		mba.notifyDataSetChanged();
	}
	else if(msg.what == 4){//跑马灯向外出来时
		MainActivity.this.setTitle(titleStr.substring(0, place));
	}
	else if(msg.what == 5){//跑马灯向里进去时
		MainActivity.this.setTitle(titleStr.substring(place, titleStr.length()));
	}
	else if(msg.what == 6){//清空美食上传界面
		msName.setText("");
		msDis.setText("");
		mshotelName.setText("");
		msLocation.setText("点击我获取经纬度");
		msPrice.setText("");
		image = null;
		msImage.setImageResource(R.drawable.click_to_photo);				
	}
	else if(msg.what == 7){//美食种类
		Bundle data = msg.getData();
		mstxSorts = (ArrayList)data.get("mstxSorts");
		..................................................
		}
	else if(msg.what == 8){//搜索界面的美食种类
		Bundle data = msg.getData();
		mstxSorts = (ArrayList)data.get("mstxSorts");
		.............................................
		msSort.setAdapter(ba);
		ba.notifyDataSetChanged();				
		}
	}
};

(2)在Thread类中发送消息

new Thread(){//该线程用于标题栏跑马灯的实现
	public void run(){
	boolean control = true;
	while(true){
			if(control){//出来时
						myHandler.sendEmptyMessage(4);
					try{
						Thread.sleep(300);//睡觉300毫秒
					}
					catch(Exception e){//捕获异常 
						e.printStackTrace();//打印异常
					}
					if(place >= titleStr.length()){
						place = 1;
						control = false;
					}
					else {
						place++;
					}
				}
				else{//进去
						myHandler.sendEmptyMessage(5);//发送Handler消息
				try{
					Thread.sleep(200);//睡觉300毫秒
				}
				catch(Exception e){//捕获异常 
					e.printStackTrace();//打印异常
				}
				if(place >= titleStr.length()){
					place = 1;
					control = true;
				}
				else {
					place++;//将place加一
				}
			}
		}
	}
}.start();

(3)在适合的地方发出信息

myHandler.sendEmptyMessage(4);
myHandler.sendEmptyMessage(5);//发送Handler消息
myHandler.sendEmptyMessage(6);

4.Handler+Runnable:

在Android里定时更新 UI，通常使用的是 java.util.Timer, java.util.TimerTask, android.os.Handler组合。实际上Handler 自身已经提供了定时的功能

(1)例子一

private Handler handler = new Handler();  
  
    private Runnable myRunnable= new Runnable() {    
        public void run() {  
             
            if (run) {  
                handler.postDelayed(this, 1000);  
                count++;  
            }  
            tvCounter.setText("Count: " + count);  

        }  
    };

然后在其他地方调用

handler.post(myRunnable);

handler.post(myRunnable,time);

案例看：http://shaobin0604.javaeye.com/blog/515820

知识点总结补充：

很多初入Android或Java开发的新手对Thread、Looper、Handler和Message仍然比较迷惑，衍生的有HandlerThread、java.util.concurrent、Task、AsyncTask由于目前市面上的书籍等资料都没有谈到这些问题，今天就这一问题做更系统性的总结。我们创建的Service、Activity以及Broadcast均是一个主线程处理，这里我们可以理解为UI线程。但是在操作一些耗时操作时，比如I/O读写的大文件读写，数据库操作以及网络下载需要很长时间，为了不阻塞用户界面，出现ANR的响应提示窗口，这个时候我们可以考虑使用Thread线程来解决。

对于从事过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的封装，开发人员可以方便的处理这些异步任务。

摘录自：http://www.android123.com.cn/androidkaifa/422.html

(2)例子二：控制发送截屏的命令Runnable接口

//定义一个Handler
Handler mHandler;
//调用发送截屏的Intent的Runnable 
//Causes the Runnable r to be added to the message queue, to be run after the specified amount of time elapses
mHandler.postDelayed(mScreenshotChordLongPress, 500);

//不调用发送截屏的Intent的Runnable 
//Remove any pending posts of Runnable r that are in the message queue.
mHandler.removeCallbacks(mScreenshotChordLongPress);

//定义一个Runnable ，其主要的操作是发送截屏的Intent
private final Runnable mScreenshotChordLongPress = new Runnable() {
   public void run() {
	//send intent :com.android.CAPTURE_SCREEN
	mContext.sendBroadcast(new Intent("com.android.CAPTURE_SCREEN"));			
   }
};

(3)多长时间显示进度条

//Handler处理消息
final Handler handler = new Handler();

final ProgressDialog progressDialog = new ProgressDialog(this);
progressDialog.setMessage(getText(R.string.adding_recipients));
progressDialog.setIndeterminate(true);
progressDialog.setCancelable(false);

final Runnable showProgress = new Runnable() {
	public void run() {
		progressDialog.show();
	}
};

// Only show the progress dialog if we can not finish off parsing the return data in 1s,
// otherwise the dialog could flicker.
handler.postDelayed(showProgress, 1000);

new Thread(new Runnable() {
	public void run() {
		final ContactList list;
		try {
             //数据处理
           } finally {
				handler.removeCallbacks(showProgress);
				progressDialog.dismiss();
           }
               
	final Runnable populateWorker = new Runnable() {
		public void run() {
			mConversation.setRecipients(list);
			mRecipientsEditor.populate(list);
			updateTitle(list);
			}
	};
	handler.post(populateWorker);
	}
}).start();

四： 控制显示一个文本（ TextView ）

//功能是把一个文本显示1.5秒后消失
private TextView overlay = null;
LayoutInflater inflater = LayoutInflater.from(this);  	
overlay = (TextView) inflater.inflate(R.layout.overlay, null);  

private Handler handler;
handler = new Handler();

private OverlayThread overlayThread;
overlayThread = new OverlayThread();

overlay.setText(sections[position]);
overlay.setVisibility(View.VISIBLE);				
handler.removeCallbacks(overlayThread);
/*****延迟一秒后执行，让overlay为不可见*****/
handler.postDelayed(overlayThread, 1500);


/**
* 类描述：OverlayThread：实现设置overlay不可见
*  @author hexiaoming
*  @version  
*/
private class OverlayThread implements Runnable {
    	
/** 
* 方法描述：run方法
* @param   
* @return  
* @see OverlayThread
*/
public void run() {
	overlay.setVisibility(View.GONE);
}   	
}