Android Handler

一.一个问题

有这样一个问题值得我们思考，若把一些类似于下载的功能（既耗时且不一定有结果）写在Activity(主线程)里，会导致Activity阻塞，长时间无响应，直至页面假死(如果5秒钟还没有完成的话，会收到Android系统的一个错误提示 "强制关闭")。因此，我们需要把这些耗时的操作放在单独的子线程中操作。这就是Handler的使命。Handler提供异步处理的功能，发送和接收不是同时的(Activity的主线程和线程队列里的线程是不同的线程，并行进行，互不影响)。

二.Handler简介

Handler 为Android操作系统中的线程通信工具，它主要由两个作用：(1)安排消息或Runnable 在某个主线程中某个地方执行(2)安排一个动作在另外的线程中执行。每个Handler对象维护两个队列(FIFO)，消息队列和Runnable队列， 都是有Android操作系统提供的。Handler可以通过这两个队列来分别：

1. 发送、接受、处理消息–消息队列；
2. 启动、结束、休眠线程–Runnable队列；

Handler的使用方法大体分为3个步骤：1.创建Handler对象。2.创建Runnable和消息。3.调用post以及sendMessage方法将Runnable和消息添加到队列。

三.Runnable队列

1.java中的线程

在java中，线程的创建有两种方法：继承Thread类和实现Runnable接口。而这最重要的都是要复写run方法来实现线程的功能。当线程的时间片到了，开始运行时，就执行run()函数，执行完毕，就进入死亡状态。

举个创建线程的例子：

 
 
Runnable r=new Runnable(){ 
 
@Override 
public void run() { 
// TODO Auto-generated method stub 
System.out.println("thread"); 
handler.postDelayed(thread, 3000); 
} 
}; 

2.关于Runnable队列

(1)原理

Android的线程异步处理机制：Handler对象维护一个线程队列，有新的Runnable送来（post()）的时候,把它放在队尾，而处理 Runnable的时候，从队头取出Runnable执行。当向队列发送一个Runnable后，立即就返回，并不理会Runnable是否被执行，执行 是否成功等。而具体的执行则是当排队排到该Runnable后系统拿来执行的。这就好比邮局的例子。寄信者将信写好后放入邮筒就回家了，他并不知道邮件何 时被邮局分发，何时寄到，对方怎样读取这些事。这样，就实现了Android的异步处理机制。

(2)具体操作

向队列添加线程：

handler.post(Runnable );将Runnable直接添加入队列

handler.postDelayed(Runnable, long)延迟一定时间后，将Runnable添加入队列

handler.postAtTime(Runnable,long)定时将Runnable添加入队列

终止线程：

handler.removeCallbacks(thread);将Runnable从Runnable队列中取出

四.消息队列

1.消息对象

(1)Message对象

Message对象携带数据，通常它用arg1,arg2来传递消息，当然它还可以有obj参数，可以携带Bundle数据。它的特点是系统性能消耗非常少。

初始化： Message msg=handler.obtainMessage();

(2)Bundle对象

Bundle是Android提供的类，可以把它看做是特殊的Map，即键值对的包。而它特殊在键和值都必须要是基本数据类型或是基本数据类型的数组（Map的键值要求都是对象），特别的，键要求都是String类型。用Message来携带Bundle数据：

放入：msg.setData(Bundle bundle);

取出：msg.getData();

2.关于消息队列

(1)原理

Android的消息异步处理机制：Handler对象维护一个消息队列，有新的消息送来（sendMessage()）的时候，把它放在队尾，之后排队 到处理该消息的时候，由主线程的Handler对象处理(handleMessage())。整个过程也是异步的，和Runnable队列的原理相同。

(2)具体操作：

向队列添加Runnable：handler.sendMessage(Message);

将消息发送到消息队列msg.sendToTarget();

延迟一定时间后，将消息发送到消息队列 handler.sendMessageDelayed(Message,long);

定时将消息发送到消息队列 handler.sendMessageAtTime(Message,long)

处理消息：

消息的具体处理过程，需要在new Handler对象时使用匿名内部类重写Handler的handleMessage(Message msg)方法，如下：

 
 
Handler handler=new Handler(){ 
 
@Override 
public void handleMessage(Message msg) { 
// TODO Auto-generated method stub 
。。。。。。 
 
。。。。。。 
} 
}; 

五.Handler的两个作用

1.安排消息或Runnable 在某个主线程中某个地方执行

代码示例：

 
 
public class HandlerTestActivity extends Activity { 
private Button start; 
@Override 
protected void onCreate(Bundle savedInstanceState) { 
// TODO Auto-generated method stub 
super.onCreate(savedInstanceState); 
setContentView(R.layout.handlertest); 
start=(Button) findViewById(R.id.start); 
start.setOnClickListener(new startListener()); 
 
System.out.println("Activity Thread:"+Thread.currentThread().getId()); 
} 
Handler handler=new Handler(); 
Runnable thread=new Runnable(){ 
 
@Override 
public void run() { 
// TODO Auto-generated method stub 
System.out.println("HandlerThread:"+Thread.currentThread().getId()); 
 
} 
}; 
class startListener implements OnClickListener{ 
 
@Override 
public void onClick(View v) { 
// TODO Auto-generated method stub 
handler.post(thread); 
} 
} 
 
} 

这个小程序中，首先程序启动，进入onCreate（），打印出当前线程（即主线程）的ID，之后点击按钮start，会将线程thread添加到线程队 列，执行线程thread，thread的作用就是打印出当前线程的ID。在这个程序中，我们可以看到通过Handler我们可以实现安排 Runnable 在某个主线程中某个地方执行，即作用(1)。

不过这里有个小小的陷阱，你发现了吗？这个程序看上去似乎实现了Handler的异步机制， handler.post(thread)似乎实现了新启线程的作用，不过通过执行我们发现，两个线程的ID相同！也就是说，实际上thread还是原来 的主线程，由此可见，handler.post()方法并未真正新建线程，只是在原线程上执行而已，我们并未实现异步机制。

2.安排一个动作在另外的线程中执行。

(1)java中标准的创建线程的方法

第一步：

 
 
 Runnable r=new Runnable(){ 
 
@Override 
public void run() { 
// TODO Auto-generated method stub 
System.out.println("thread"); 
handler.postDelayed(thread, 3000); 
} 
}; 

第二步：

 
 
Thread t=new Thread (r); 

第三步：

 
 
t.start(); 

若把上面示例程序中的handler.post(thread);语句改成以上形式，通过打印我们可以看到，两个ID是不同的，新的线程启动了！

(2)关于Looper

Looper类用来为线程开启一个消息循环，作用是可以循环的从消息队列读取消息，所以Looper实际上就是消息队列+消息循环的封装。每个线程只能对应一个Looper，除主线程外，Android中的线程默认是没有开启Looper的。

通过Handler与Looper交互，Handler可以看做是Looper的接口，用来向指定的Looper发送消息以及定义处理方法。默认情况下Handler会与其所在线程的Looper绑定，即：

Handler handler=new Handler();等价于Handler handler=new Handler(Looper.myLooper());

Looper有两个主要方法：

Looper.prepare();启用Looper
Looper.loop(); 让Looper开始工作，从消息队列里取消息，处理消息。

注意：写在Looper.loop()之后的代码不会被执行，这个函数内部应该是一个循环，当调用mHandler.getLooper().quit()后，loop才会中止，其后的代码才能得以运行。

(3)Handler异步机制的实现

Handler是通过HandlerThread 使得子线程与主线程分属不同线程的。实际上，HandlerThread 是一个特殊的线程，它是一个封装好Looper的线程，

代码示例：

 
 
 //创建一个名叫handler_hread的HandlerThread 对象 
HandlerThread handlerThread=new HandlerThread("handler_hread"); 
 
//开启handlerThread，在使用handlerThread.getLooper()之前必须先调用start方法，否则取出的是空 
handlerThread.start(); 
 
//将handler绑定在handlerThread的Looper上，即这个handler是运行在handlerThread线程中的 
myHandler handler=new myHandler(handlerThread.getLooper()); 
 
class myHandler extends Handler{ 
public myHandler(){} 
public myHandler(Looper looper){ 
super(looper); 
} 
@Override 
public void handleMessage(Message msg) { 
// TODO Auto-generated method stub 
System.out.println("Activity Thread:"+Thread.currentThread().getId()); 
} 
} 

这样，就实现了handler的异步处理机制，在调用handler.post()方法，通过打印线程ID可以得知，子线程与主线程是分属不同线程的。

-------------------------------------------------------------------------------------------------------------

Android笔记-ListView总结(多选框ListViiew,动态加载，多线程更新ListView中的进度条)

Why ListView?

ListView 如果仅仅出于功能上的需求ListView可能没有存在的必要，ListView能作的事情基本上ScrollView也能胜任。ListView存在的最根本的原因在于它的高效（如何实现的？）.ListView通过对象的复用从而减少内存的消耗，也减少了对象的创建从而也减少的cpu的消耗(在Androidk中创建View对象经常伴随着解析xml)。ListView的本质是一张bitmap(当然所有的控件文字等在屏幕上看到的最终都会变成bitmap),ListView会按照需求，根据Adapter提供的信息把需要的Item画出来显示在屏幕上，当屏幕滚动的时候会重新计算Item的位置并绘制出新的bitmap显示在屏幕上。这样听起来感觉可能不是很高效，但这样带的好处就是，每用为一第个Item 创建一个View对象，样式一样的对象可以共用一个View对象，减少了内存的消耗。而且ListView是事件驱动的，只有当需要的时候才会重新绘制，并且只会 绘制当前屏幕上所显示的Items.

How To Use?

ListView 离不开Adapter,通常的作法创建一个类继承BaseAdapter，Override getCount()和getView()等方法。生成这个类的对象，调用ListView的setAdapter()与ListViw进行绑定。

How Does It work?

ListView会调用跟其绑定的Adapter的getCount()方法知道有多少个Item需要展示，然后循环调用getView(int position, View convertView, ViewGroup parent)知道第position个Item该怎么画，并画出来直到把当前的ListView的空间填满。当Adapter当中的数据改变时，需调用notifyDataSetChanged ()告诉Adapter数据发生了变化或者给Adapter注册一个观察者registerDataSetObserver (DataSetObserver observer)。当Adapter得知与其绑定的数据己发生改变时间，会再次调用getCount()方法，并循环调用getView(int position, View convertView, ViewGroup parent)刷新当前页面。

Item 1

Item 2

Item 3

Item 4

Item 5

Item 6

Item 7

Item 8

当这个ListView 向上滚动需要创建一个Item9 同时，有些对象(比如Item1 )不在显示区域将看不到，这时android 将会把item1 的 引用传递给 Adapter.getView() 中的convertView这样我们就不用再创建一个View来存放Item9，只需要把原来的item1对象作下修改，就可以重复使用了 ；我们也不用担心convertView 是不是正确的类型，这个由系统保证，所以我们要作的就是把convertView 转换(经常需要向下转型)成我们自己的View 再给它赋值，in this case ：(TextView) convertView.setText(“Item9”);

    
    

     
     public
     
      View getView(
     
     int
     
      position, View convertView, ViewGroup parent) {
    
     
     if
     
      (convertView 
     
     ==
     
      
     
     null
     
     ) {
        
     
     //
     
     this would be first time to show the item,so we need to create it
     
     

     
             convertView 
     
     =
     
      mInflater.inflate(R.layout.item, 
     
     null
     
     );
    }
    
     
     //
     
     we grab the convertView,modify it and reuse it
     
     

     
         ((TextView) convertView.findViewById(R.id.text)).setText(DATA[position]);
    
     
     return
     
      convertView;
}
    
    

调用方法所需要的消耗要比访问变量高得多，而上面的代码一次又一次的调用findViewById()方法，作着重复的事情。所以我们可以进一步进行如下优化： 创建一个类用来保存一些View的引用，这样我们就可以直接使用，而不用再调用findViewById().因为我们所保存的只是引用不是对象本身，所以不用担心会占用大量内存

    
    

     
     static
     
      
     
     class
     
      ViewHolder {
    TextView text;
    ImageView icon;
}


     
     public
     
      View getView(
     
     int
     
      position, View convertView, ViewGroup parent){
    ViewHolder holder;
    
     
     if
     
      (convertView 
     
     ==
     
      
     
     null
     
     ) {
        convertView 
     
     =
     
      mInflater.inflate(R.layout.list_item_icon_text, 
     
     null
     
     );
        holder 
     
     =
     
      
     
     new
     
      ViewHolder();
        holder.text 
     
     =
     
      (TextView) convertView.findViewById(R.id.text);
        holder.icon 
     
     =
     
      (ImageView) convertView.findViewById(R.id.icon);
        convertView.setTag(holder);
    } 
     
     else
     
      {
        holder 
     
     =
     
      (ViewHolder) convertView.getTag();
    }
    
     
     //
     
     we store the reference ,so that we don’t have to call findViewById() over and over again
     
     

     
         holder.text.setText(DATA[position]);
    holder.icon.setImageBitmap((position 
     
     &
     
      
     
     1
     
     ) 
     
     ==
     
      
     
     1
     
      
     
     ?
     
      mIcon1 : mIcon2);
    
     
     return
     
      convertView;
}
    
    

上图是T-mobile g1上采集的的数据，现在看来可能现在不是很准确，但其性能上的差异还是很有参考价值的。

Tips & Tricks

ListView是为了大容量数据展示而设计的。如果数据量(Item的数量)不是很大，且用ListView实现起来比较麻烦，不妨换种思路，不使用ListView，而用ScrollView来实现。

如果Item信息布局比较复杂或者Item的数量很多，出于性能的考虑，建议自定义一个View组件实现需要的功能，而不是组合其它控件达到所要的效果。

ListView滚动变黑：在xml中给ListView增加一个属性android:cacheColorHint="#00000000" 。当ListVIew中有很多Item，有时候需要快速的滚动。比如从第一个Item滚动到第600个Item这个时候，中间的很多Item对用户来说意义不是很大，但android却要调用 adapter.getView()方法将这些Item逐一画出，并且因为滚动很快用户不希望有任何的延迟。这在一些低端手机比如g1，是很难作到的。所以google工程师想出的一个办法是在滚动的时候，让屏幕变黑用一张黑色bitmap盖住ListView，而不去绘制中间过程中的很多Item，从而提升性能。

Item有自己的背景盖住了Selector光标：在xml中给ListView增加一个属性：android:drawSelectorOnTop="true"这样光标就会跑到Item上面的图层，解决我们的问题。

Snippets

多选框ListView

   

带有进度条的ListView，多个子线程刷新各自的进度，如果子线程很多那么刷新就会变得很频繁，我们可以由一个handler负责统一刷新，这样我们就要以增加一些额外条件限制刷新的次数和条件

分批加载的原理很简单，给ListView添加一个OnScrollListener监听滚动事件，当用户滚动到屏幕到特定的位置时加载新数据，并给LIstView加一个正在加载的footerView，当加载数据结束时再把这个footerView去掉。