如何高效使用和管理Bitmap--图片缓存管理模块的设计与实现

传送门 ☞ 轮子的专栏 ☞ 转载请注明 ☞ http://blog.csdn.net/leverage_1229

        上周为360全景项目引入了图片缓存模块。因为是在Android4.0平台以上运作，出于惯性，都会在设计之前查阅相关资料，尽量避免拿一些以前2.3平台积累的经验来进行类比处理。开发文档中有一个BitmapFun的示例，仔细拜读了一下，虽说围绕着Bitmap的方方面面讲得都很深入，但感觉很难引入到当前项目中去。

        现在的图片服务提供者基本上都来源于网络。对于应用平台而言，访问网络属于耗时操作。尤其是在移动终端设备上，它的显著表现为系统的延迟时间变长、用户交互性变差等。可以想象，一个携带着这些问题的应用在市场上是很难与同类产品竞争的。

        说明一下，本文借鉴了Keegan小钢和安卓巴士的处理模板，主要针对的是4.0以上平台应用。2.3以前平台执行效果未知，请斟酌使用或直接略过：），当然更欢迎您把测试结果告知笔者。

1图片加载流程

        首先，我们谈谈加载图片的流程，项目中的该模块处理流程如下：
        在UI主线程中，从内存缓存中获取图片，找到后返回。找不到进入下一步；

        在工作线程中，从磁盘缓存中获取图片，找到即返回并更新内存缓存。找不到进入下一步；

        在工作线程中，从网络中获取图片，找到即返回并同时更新内存缓存和磁盘缓存。找不到显示默认以提示。

2内存缓存类（PanoMemCache）

        这里使用Android提供的LruCache类，该类保存一个强引用来限制内容数量，每当Item被访问的时候，此Item就会移动到队列的头部。当cache已满的时候加入新的item时，在队列尾部的item会被回收。

[java]
view plaincopyprint?

public class PanoMemoryCache {  
  
    // LinkedHashMap初始容量  
    private static final int INITIAL_CAPACITY = 16;  
    // LinkedHashMap加载因子  
    private static final int LOAD_FACTOR = 0.75f;  
    // LinkedHashMap排序模式  
    private static final boolean ACCESS_ORDER = true;  
  
    // 软引用缓存  
    private static LinkedHashMap<String, SoftReference<Bitmap>> mSoftCache;  
    // 硬引用缓存  
    private static LruCache<String, Bitmap> mLruCache;  
      
    public PanoMemoryCache() {  
    // 获取单个进程可用内存的最大值  
    // 方式一：使用ActivityManager服务（计量单位为M）  
        /*int memClass = ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass();*/  
    // 方式二：使用Runtime类（计量单位为Byte）  
        final int memClass = (int) Runtime.getRuntime().maxMemory();  
        // 设置为可用内存的1/4（按Byte计算）  
        final int cacheSize = memClass / 4;  
        mLruCache = new LruCache<String, Bitmap>(cacheSize) {  
            @Override  
            protected int sizeOf(String key, Bitmap value) {  
                if(value != null) {  
                    // 计算存储bitmap所占用的字节数  
                    return value.getRowBytes() * value.getHeight();  
                } else {  
                    return 0;  
                }  
            }  
              
            @Override  
            protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {  
                if(oldValue != null) {  
                    // 当硬引用缓存容量已满时，会使用LRU算法将最近没有被使用的图片转入软引用缓存  
                    mSoftCache.put(key, new SoftReference<Bitmap>(oldValue));  
                }  
            }  
        };  
          
    /* 
    * 第一个参数：初始容量（默认16） 
    * 第二个参数：加载因子（默认0.75） 
    * 第三个参数：排序模式（true：按访问次数排序；false：按插入顺序排序） 
    */  
        mSoftCache = new LinkedHashMap<String, SoftReference<Bitmap>>(INITIAL_CAPACITY, LOAD_FACTOR, ACCESS_ORDER) {  
            private static final long serialVersionUID = 7237325113220820312L;  
            @Override  
            protected boolean removeEldestEntry(Entry<String, SoftReference<Bitmap>> eldest) {  
                if(size() > SOFT_CACHE_SIZE) {  
                    return true;  
                }  
                return false;  
            }  
        };  
    }  
      
    /** 
     * 从缓存中获取Bitmap 
     * @param url 
     * @return bitmap 
     */  
    public Bitmap getBitmapFromMem(String url) {  
        Bitmap bitmap = null;  
        // 先从硬引用缓存中获取  
        synchronized (mLruCache) {  
            bitmap = mLruCache.get(url);  
            if(bitmap != null) {  
                // 找到该Bitmap之后，将其移到LinkedHashMap的最前面，保证它在LRU算法中将被最后删除。  
                mLruCache.remove(url);  
                mLruCache.put(url, bitmap);  
                return bitmap;  
            }  
        }  
  
  
        // 再从软引用缓存中获取  
        synchronized (mSoftCache) {  
            SoftReference<Bitmap> bitmapReference = mSoftCache.get(url);  
            if(bitmapReference != null) {  
                bitmap = bitmapReference.get();  
                if(bitmap != null) {  
                    // 找到该Bitmap之后，将它移到硬引用缓存。并从软引用缓存中删除。  
                    mLruCache.put(url, bitmap);  
                    mSoftCache.remove(url);  
                    return bitmap;  
                } else {  
                    mSoftCache.remove(url);  
                }  
            }  
        }  
        return null;  
    }  
      
    /** 
     * 添加Bitmap到内存缓存 
     * @param url 
     * @param bitmap 
     */  
    public void addBitmapToCache(String url, Bitmap bitmap) {  
        if(bitmap != null) {  
            synchronized (mLruCache) {  
              mLruCache.put(url, bitmap);    
            }  
        }  
    }  
      
    /** 
     * 清理软引用缓存 
     */  
    public void clearCache() {  
        mSoftCache.clear();  
    mSoftCache = null;  
    }  
}  

        补充一点，由于4.0平台以后对SoftReference类引用的对象调整了回收策略，所以该类中的软引用缓存实际上没什么效果，可以去掉。2.3以前平台建议保留。

3磁盘缓存类（PanoDiskCache）

[java]
view plaincopyprint?

public class PanoDiskCache {  
      
    private static final String TAG = "PanoDiskCache";  
  
    // 文件缓存目录  
    private static final String CACHE_DIR = "panoCache";  
    private static final String CACHE_FILE_SUFFIX = ".cache";  
      
    private static final int MB = 1024 * 1024;  
    private static final int CACHE_SIZE = 10; // 10M  
    private static final int SDCARD_CACHE_THRESHOLD = 10;  
      
    public PanoDiskCache() {  
        // 清理文件缓存  
        removeCache(getDiskCacheDir());  
    }  
      
    /** 
     * 从磁盘缓存中获取Bitmap 
     * @param url 
     * @return 
     */  
    public Bitmap getBitmapFromDisk(String url) {  
        String path = getDiskCacheDir() + File.separator + genCacheFileName(url);  
        File file = new File(path);  
        if(file.exists()) {  
            Bitmap bitmap = BitmapFactory.decodeFile(path);  
            if(bitmap == null) {  
                file.delete();  
            } else {  
                updateLastModified(path);  
                return bitmap;  
            }  
        }  
        return null;  
    }  
      
    /** 
     * 将Bitmap写入文件缓存 
     * @param bitmap 
     * @param url 
     */  
    public void addBitmapToCache(Bitmap bitmap, String url) {  
        if(bitmap == null) {  
            return;  
        }  
        // 判断当前SDCard上的剩余空间是否足够用于文件缓存  
        if(SDCARD_CACHE_THRESHOLD > calculateFreeSpaceOnSd()) {  
            return;  
        }  
        String fileName = genCacheFileName(url);  
        String dir = getDiskCacheDir();  
        File dirFile = new File(dir);  
        if(!dirFile.exists()) {  
            dirFile.mkdirs();  
        }  
        File file = new File(dir + File.separator + fileName);  
        try {  
            file.createNewFile();  
            FileOutputStream out = new FileOutputStream(file);  
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);  
            out.flush();  
            out.close();  
        } catch (FileNotFoundException e) {  
            Log.e(TAG, "FileNotFoundException");  
        } catch (IOException e) {  
            Log.e(TAG, "IOException");  
        }  
    }  
      
    /** 
     * 清理文件缓存 
     * 当缓存文件总容量超过CACHE_SIZE或SDCard的剩余空间小于SDCARD_CACHE_THRESHOLD时，将删除40%最近没有被使用的文件 
     * @param dirPath 
     * @return 
     */  
    private boolean removeCache(String dirPath) {  
        File dir = new File(dirPath);  
        File[] files = dir.listFiles();  
        if(files == null || files.length == 0) {  
            return true;  
        }  
        if(!Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {  
            return false;  
        }  
          
        int dirSize = 0;  
        for (int i = 0; i < files.length; i++) {  
            if(files[i].getName().contains(CACHE_FILE_SUFFIX)) {  
                dirSize += files[i].length();  
            }  
        }  
        if(dirSize > CACHE_SIZE * MB || SDCARD_CACHE_THRESHOLD > calculateFreeSpaceOnSd()) {  
            int removeFactor = (int) (0.4 * files.length + 1);  
            Arrays.sort(files, new FileLastModifiedSort());  
            for (int i = 0; i < removeFactor; i++) {  
                if(files[i].getName().contains(CACHE_FILE_SUFFIX)) {  
                    files[i].delete();  
                }  
            }  
        }  
          
        if(calculateFreeSpaceOnSd() <= SDCARD_CACHE_THRESHOLD) {  
            return false;  
        }  
        return true;  
    }  
      
    /** 
     * 更新文件的最后修改时间 
     * @param path 
     */  
    private void updateLastModified(String path) {  
        File file = new File(path);  
        long time = System.currentTimeMillis();  
        file.setLastModified(time);  
    }  
      
    /** 
     * 计算SDCard上的剩余空间 
     * @return 
     */  
    private int calculateFreeSpaceOnSd() {  
        StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());  
        double sdFreeMB = ((double) stat.getAvailableBlocks() * (double) stat.getBlockSize()) / MB;  
        return (int) sdFreeMB;  
    }  
  
  
    /** 
     * 生成统一的磁盘文件后缀便于维护 
     * 从URL中得到源文件名称，并为它追加缓存后缀名.cache 
     * @param url 
     * @return 文件存储后的名称 
     */  
    private String genCacheFileName(String url) {  
        String[] strs = url.split(File.separator);  
        return strs[strs.length - 1] + CACHE_FILE_SUFFIX;  
    }  
      
    /** 
     * 获取磁盘缓存目录 
     * @return 
     */  
    private String getDiskCacheDir() {  
        return getSDPath() + File.separator + CACHE_DIR;  
    }  
      
    /** 
     * 获取SDCard目录 
     * @return 
     */  
    private String getSDPath() {  
        File sdDir = null;  
        // 判断SDCard是否存在  
        boolean sdCardExist = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);  
        if(sdCardExist) {  
            // 获取SDCard根目录  
            sdDir = Environment.getExternalStorageDirectory();  
        }  
        if(sdDir != null) {  
            return sdDir.toString();  
        } else {  
            return "";  
        }  
    }  
      
    /** 
     * 根据文件最后修改时间进行排序 
     */  
    private class FileLastModifiedSort implements Comparator<File> {  
        @Override  
        public int compare(File lhs, File rhs) {  
            if(lhs.lastModified() > rhs.lastModified()) {  
                return 1;  
            } else if(lhs.lastModified() == rhs.lastModified()) {  
                return 0;  
            } else {  
                return -1;  
            }  
        }  
    }  
}  

4图片工具类（PanoUtils）

4.1从网络上获取图片：downloadBitmap()

[java]
view plaincopyprint?

/** 
    * 从网络上获取Bitmap，并进行适屏和分辨率处理。 
    * @param context 
    * @param url 
    * @return 
    */  
   public static Bitmap downloadBitmap(Context context, String url) {  
       HttpClient client = new DefaultHttpClient();  
       HttpGet request = new HttpGet(url);  
         
       try {  
           HttpResponse response = client.execute(request);  
           int statusCode = response.getStatusLine().getStatusCode();  
           if(statusCode != HttpStatus.SC_OK) {  
               Log.e(TAG, "Error " + statusCode + " while retrieving bitmap from " + url);  
               return null;  
           }  
             
           HttpEntity entity = response.getEntity();  
           if(entity != null) {  
               InputStream in = null;  
               try {  
                   in = entity.getContent();  
                   return scaleBitmap(context, readInputStream(in));  
               } finally {  
                   if(in != null) {  
                       in.close();  
                       in = null;  
                   }  
                   entity.consumeContent();  
               }  
           }  
       } catch (IOException e) {  
           request.abort();  
           Log.e(TAG, "I/O error while retrieving bitmap from " + url, e);  
       } catch (IllegalStateException e) {  
           request.abort();  
           Log.e(TAG, "Incorrect URL: " + url);  
       } catch (Exception e) {  
           request.abort();  
           Log.e(TAG, "Error while retrieving bitmap from " + url, e);  
       } finally {  
           client.getConnectionManager().shutdown();  
       }  
       return null;  
   }     

4.2从输入流读取字节数组，看起来是不是很眼熟啊！

[java]
view plaincopyprint?

public static byte[] readInputStream(InputStream in) throws Exception {  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        byte[] buffer = new byte[1024];  
        int len = 0;  
        while((len = in.read(buffer)) != -1) {  
            out.write(buffer, 0, len);  
        }  
        in.close();  
        return out.toByteArray();  
    }      

4.3对下载的源图片进行适屏处理，这也是必须的：）

[java]
view plaincopyprint?

/** 
     * 按使用设备屏幕和纹理尺寸适配Bitmap 
     * @param context 
     * @param in 
     * @return 
     */  
    private static Bitmap scaleBitmap(Context context, byte[] data) {  
          
        WindowManager windowMgr = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);  
        DisplayMetrics outMetrics = new DisplayMetrics();  
        windowMgr.getDefaultDisplay().getMetrics(outMetrics);  
        int scrWidth = outMetrics.widthPixels;  
        int scrHeight = outMetrics.heightPixels;  
          
        BitmapFactory.Options options = new BitmapFactory.Options();  
        options.inJustDecodeBounds = true;  
        Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);  
        int imgWidth = options.outWidth;  
        int imgHeight = options.outHeight;  
          
        if(imgWidth > scrWidth || imgHeight > scrHeight) {  
            options.inSampleSize = calculateInSampleSize(options, scrWidth, scrHeight);  
        }  
        options.inJustDecodeBounds = false;  
        bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);  
          
        // 根据业务的需要，在此处还可以进一步做处理  
        ...  
  
        return bitmap;  
    }  
      
    /** 
     * 计算Bitmap抽样倍数 
     * @param options 
     * @param reqWidth 
     * @param reqHeight 
     * @return 
     */  
    public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {  
        // 原始图片宽高  
        final int height = options.outHeight;  
        final int width = options.outWidth;  
        int inSampleSize = 1;  
      
        if (height > reqHeight || width > reqWidth) {  
      
            // 计算目标宽高与原始宽高的比值  
            final int heightRatio = Math.round((float) height / (float) reqHeight);  
            final int widthRatio = Math.round((float) width / (float) reqWidth);  
      
            // 选择两个比值中较小的作为inSampleSize的值  
            inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;  
            if(inSampleSize < 1) {  
                inSampleSize = 1;  
            }  
        }  
  
        return inSampleSize;  
    }  

5使用decodeByteArray()还是decodeStream()？

        讲到这里，有童鞋可能会问我为什么使用BitmapFactory.decodeByteArray(data, 0, data.length, opts)来创建Bitmap，而非使用BitmapFactory.decodeStream(is, null, opts)。你这样做不是要多写一个静态方法readInputStream()吗？

        没错，decodeStream()确实是该使用情景下的首选方法，但是在有些情形下，它会导致图片资源不能即时获取，或者说图片被它偷偷地缓存起来，交还给我们的时间有点长。但是延迟性是致命的，我们等不起。所以在这里选用decodeByteArray()获取，它直接从字节数组中获取，贴近于底层IO、脱离平台限制、使用起来风险更小。

6引入缓存机制后获取图片的方法

[java]
view plaincopyprint?

/** 
     * 加载Bitmap 
     * @param url 
     * @return 
     */  
    private Bitmap loadBitmap(String url) {  
        // 从内存缓存中获取，推荐在主UI线程中进行  
        Bitmap bitmap = memCache.getBitmapFromMem(url);  
        if(bitmap == null) {  
            // 从文件缓存中获取，推荐在工作线程中进行  
            bitmap = diskCache.getBitmapFromDisk(url);  
            if(bitmap == null) {  
                // 从网络上获取，不用推荐了吧，地球人都知道~_~  
                bitmap = PanoUtils.downloadBitmap(this, url);  
                if(bitmap != null) {  
                    diskCache.addBitmapToCache(bitmap, url);  
                    memCache.addBitmapToCache(url, bitmap);  
                }  
            } else {  
                memCache.addBitmapToCache(url, bitmap);  
            }  
        }  
        return bitmap;  
    }  

7工作线程池化管理

        有关多线程的切换问题以及在UI线程中执行loadBitmap()方法无效的问题，请参见另一篇博文：使用严苛模式打破Android4.0以上平台应用中UI主线程的“独断专行”。

有关工作线程的处理方式，这里推荐使用定制线程池的方式，核心代码如下：

[java]
view plaincopyprint?

// 线程池初始容量  
private static final int POOL_SIZE = 4;  
private ExecutorService executorService;  
@Override  
public void onCreate(Bundle savedInstanceState) {  
    super.onCreate(savedInstanceState);  
  
    // 获取当前使用设备的CPU个数  
    int cpuNums = Runtime.getRuntime().availableProcessors();  
    // 预开启线程池数目  
    executorService = Executors.newFixedThreadPool(cpuNums * POOL_SIZE);  
  
    ...  
    executorService.submit(new Runnable() {  
        // 此处执行一些耗时工作，不要涉及UI工作。如果遇到，直接转交UI主线程  
        pano.setImage(loadBitmap(url));  
    });  
    ...  
  
}  

        我们知道，线程构造也是比较耗资源的。一定要对其进行有效的管理和维护。千万不要随意而行，一张图片的工作线程不搭理也许没什么，当使用场景变为ListView和GridView时，线程池化工作就显得尤为重要了。Android不是提供了AsyncTask吗？为什么不用它？其实AsyncTask底层也是靠线程池支持的，它默认分配的线程数是128，是远大于我们定制的executorService。

使用严苛模式打破Android4.0以上平台应用中UI主线程的“独断专行”

最近单位来了一个Android4.1平台的360街景项目。在编写该项目demo的过程中，为了省事，打算直接在UI线程中访问网络数据源并生成Bitmap以填充相应的视图。访问网络模块的封装采用了HttpClient的方式进行构建。编写完工后执行程序，发现视图显示的还是本地的默认图样。在确认了网络权限已被开启的情况下，我开始怀疑是不是HttpClient封装的粒度过大，导致其适用范围受限的问题。于是干脆采用Java平台最底层的Socket套接字方式来实现网络访问，可是结果还是一样的，仍旧无法得到网络数据。经过调试发现，在客户端发出请求之后，根本无法连接到服务端，也就无法解析后续的服务端的响应内容了。

        以前在Android2.3.3平台上研发怎么没有这个现象？难道是Android4.0的单线程模式的“禁令”较之以往更为严格了。为了使应用程序具有更好的交互性和更少的延迟时间，强势要求开发人员在UI主线程中只能执行与UI相关的工作（如：更新视图、与用户交互等），其他方面的工作一律禁止执行。为了验证这个相反，在stackoverflow.com检索了相关议题，从一位Google工程师的解答中基本得到了印证。也就是说，如果你非要在UI主线程中执行其他工作（如：访问网络、文件操作等），其实有这种编程强迫症的人在项目初期还是很多的，笔者就是其中的一位。你需要为UI主线程所在的Activity设置线程策略，告知平台请赋予我在UI主线程中进行其他工作的权限。具体做法有如下：

        在你的Application、Activity或其它应用容器中添加如下代码：

[java]
view plaincopyprint?

public void onCreate() {  
    if (DEVELOPER_MODE) {  
        StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()  
                .detectDiskReads() // 捕捉读取磁盘  
                .detectDiskWrites() // 捕捉写入磁盘  
                .detectNetwork()   // 捕捉网络访问 或使用detectAll() 火力全开  
                .penaltyLog() // 捕捉LogCat日志  
                .build());  
        StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()  
                .detectLeakedSqlLiteObjects()  
                .detectLeakedClosableObjects()  
                .penaltyLog()  
                .penaltyDeath()  
                .build());  
    }  
    super.onCreate();  
}  

StrictMode类

        StrictMode是一个开发者工具类，从Android 2.3平台开始被引入。可以用于捕捉发生在应用程序UI主线程中耗时的IO操作、网络访问或方法调用；也可以用来改进应用程序，使得UI主线程在处理IO操作和访问网络时显得更平滑，避免其被阻塞，导致ANR警告。更多有关StrictMode的信息，请参见http://developer.android.com/reference/android/os/StrictMode.html。

        这种非常规的做法，是在项目初期和开发模式下为了达到更高的效率，而采取一种提高生产效率做法。在产品交付和运维时，我们还是要严格遵守Android平台进程与线程安全管理机制。接下来是在实际开发中应该遵循的两个原则：

UI主线程

        在UI主线程中，只处理与UI相关及用户交互的工作，耗时的工作一律交由后台工作线程去搭理。常见的耗时工作处理方式有：

AsyncTask;

Handler、MessageQueue、Looper;

ExecutorService(execute/submit)

工作线程

        在工作线程中，只做自己分内的事。决不干涉UI主线程的工作。在执行过程中如果存在涉及到UI的操作（如：更新视图、重绘等），一律将其转交给UI主线程进行处理。常见的转交方式有:

Activity.runOnUiThread(new Runnable(){...});

View.post(new Runnable(){...});

View.postDelay(Runnable(){...},long)

示例

        最后，提供AsyncMultiThreadActivity演示Android多线程与UI交互的方式，仅供读者参考使用。

[java]
view plaincopyprint?

public class AsyncMultiThreadActivity extends Activity {    
     
    private TextView txView;    
    private Button button;    
    /** Called when the activity is first created. */   
    @Override   
    public void onCreate(Bundle savedInstanceState) {    
        Log.i("RootyInfo", "oncreate");    
        super.onCreate(savedInstanceState);    
        setContentView(R.layout.main);        
             
        txView=(TextView)findViewById(R.id.textView1);    
        button=(Button)findViewById(R.id.button1);    
        button.setOnClickListener(new OnClickListener() {    
                 
            @Override   
            public void onClick(View v) {  
                     
                //创建一个用于展示前三种后台线程和UI线程交互的线程    
                new TestThread(MainActivity.this).start();    
                     
                //创建一个用于展示AsyncTask实现交互的TestAsyncTask    
                new TestAsyncTask().execute("Test"," AsyncTask");    
            }    
        });    
    }    
         
         
    class TestAsyncTask extends AsyncTask<String, Integer, String> {    
        //TestAsyncTask被后台线程执行后，被UI线程被调用，一般用于初始化界面控件，如进度条    
        @Override   
        protected void onPreExecute() {    
  
            super.onPreExecute();    
        }    
     
        //doInBackground执行完后由UI线程调用，用于更新界面操作    
        @Override   
        protected void onPostExecute(String result) {    
  
            txView.setText(result);    
            super.onPostExecute(result);    
        }    
     
        //在PreExcute执行后被启动AysncTask的后台线程调用，将结果返回给UI线程    
        @Override   
        protected String doInBackground(String... params) {    
  
            StringBuffer sb=new StringBuffer();    
            for (String string : params) {    
                sb.append(string);    
            }    
            return sb.toString();    
        }    
             
    }  
    
    //用于线程间通信的Handler    
    class TestHandler extends Handler {    
             
        public TestHandler(Looper looper) {    
            super(looper);    
  
        }    
     
        @Override   
        public void handleMessage(Message msg) {    
  
            System.out.println("123");    
            txView.setText((String)msg.getData().get("tag"));    
            super.handleMessage(msg);    
        }    
             
    }   
   
    //后台线程类    
    class TestThread extends Thread {    
        Activity activity;    
        public TestThread(Activity activity) {         
            this.activity = activity;    
        }    
        @Override   
        public void run() {    
                 
            // 演示Activity.runOnUIThread(Runnable)方法的实现    
            activity.runOnUiThread(new Runnable() {                 
                @Override   
                public void run() {    
  
                    txView.setText("Test runOnUIThread");    
                }    
            });    
                 
            // 演示Activity.runOnUIThread(Runnable)方法的实现    
            txView.post(new Runnable() {    
                     
                @Override   
                public void run() {    
  
                    txView.setText("Test View.post(Runnable)");    
                }    
            });    
                 
            // 演示Activity.runOnUIThread(Runnable)方法的实现    
            txView.postDelayed(new Runnable() {    
                     
                @Override   
                public void run() {    
  
                    txView.setText("Test View.postDelay(Runnable,long)");    
                }    
            }, 1000);    
                 
            // 演示Handler方法的实现    
            Message msg=new Message();    
            Bundle bundle=new Bundle();    
            bundle.putString("tag", "Test Handler");    
            msg.setData(bundle);                
            new TestHandler(Looper.getMainLooper()).sendMessage(msg);    
                         
            super.run();    
        }    
             
    }    
        
}