Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

转载 2016年05月30日 17:53:14


上一篇博客介绍了Android异步消息处理机制,如果你还不了解,可以看:Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系 。那篇博客的最后,提出可以把异步消息处理机制不仅仅是在MainActivity中更新UI,可以用到别的地方,最近也一直在考虑这个问题,有幸,想出来一个实际的案例,将异步消息处理机制用到大量图片的加载的工具类中,其实也特别希望可以写一篇关于大量图片加载的文章,终于有机会了~先简单介绍一下:

1、概述

一般大量图片的加载,比如GridView实现手机的相册功能,一般会用到LruCache,线程池,任务队列等;那么异步消息处理可以用哪呢?

1、用于UI线程当Bitmap加载完成后更新ImageView

2、在图片加载类初始化时,我们会在一个子线程中维护一个Loop实例,当然子线程中也就有了MessageQueue,Looper会一直在那loop停着等待消息的到达,当有消息到达时,从任务队列按照队列调度的方式(FIFO,LIFO等),取出一个任务放入线程池中进行处理。

简易的一个流程:当需要加载一张图片,首先把加载图片加入任务队列,然后使用loop线程(子线程)中的hander发送一个消息,提示有任务到达,loop()(子线程)中会接着取出一个任务,去加载图片,当图片加载完成,会使用UI线程的handler发送一个消息去更新UI界面。

说了这么多,大家估计也觉得云里来雾里去的,下面看实际的例子。

2、图库功能的实现

该程序首先扫描手机中所有包含图片的文件夹,最终选择图片最多的文件夹,使用GridView显示其中的图片

1、布局文件

[html] view plaincopy在CODE上查看代码片派生到我的代码片
  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.   
  6.     <GridView  
  7.         android:id="@+id/id_gridView"  
  8.         android:layout_width="match_parent"  
  9.         android:layout_height="match_parent"  
  10.         android:cacheColorHint="@android:color/transparent"  
  11.         android:columnWidth="90dip"  
  12.         android:gravity="center"  
  13.         android:horizontalSpacing="20dip"  
  14.         android:listSelector="@android:color/transparent"  
  15.         android:numColumns="auto_fit"  
  16.         android:stretchMode="columnWidth"  
  17.         android:verticalSpacing="20dip" >  
  18.     </GridView>  
  19.   
  20. </RelativeLayout>  

布局文件相当简单就一个GridView

2、MainActivity

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.example.zhy_handler_imageloader;  
  2.   
  3. import java.io.File;  
  4. import java.io.FilenameFilter;  
  5. import java.util.Arrays;  
  6. import java.util.HashSet;  
  7. import java.util.List;  
  8.   
  9. import android.app.Activity;  
  10. import android.app.ProgressDialog;  
  11. import android.content.ContentResolver;  
  12. import android.database.Cursor;  
  13. import android.net.Uri;  
  14. import android.os.Bundle;  
  15. import android.os.Environment;  
  16. import android.os.Handler;  
  17. import android.provider.MediaStore;  
  18. import android.widget.GridView;  
  19. import android.widget.ImageView;  
  20. import android.widget.ListAdapter;  
  21. import android.widget.Toast;  
  22.   
  23. public class MainActivity extends Activity  
  24. {  
  25.     private ProgressDialog mProgressDialog;  
  26.     private ImageView mImageView;  
  27.       
  28.     /** 
  29.      * 存储文件夹中的图片数量 
  30.      */  
  31.     private int mPicsSize;  
  32.     /** 
  33.      * 图片数量最多的文件夹 
  34.      */  
  35.     private File mImgDir;  
  36.     /** 
  37.      * 所有的图片 
  38.      */  
  39.     private List<String> mImgs;  
  40.   
  41.     private GridView mGirdView;  
  42.     private ListAdapter mAdapter;  
  43.     /** 
  44.      * 临时的辅助类,用于防止同一个文件夹的多次扫描 
  45.      */  
  46.     private HashSet<String> mDirPaths = new HashSet<String>();  
  47.   
  48.     private Handler mHandler = new Handler()  
  49.     {  
  50.         public void handleMessage(android.os.Message msg)  
  51.         {  
  52.             mProgressDialog.dismiss();  
  53.             mImgs = Arrays.asList(mImgDir.list(new FilenameFilter()  
  54.             {  
  55.                 @Override  
  56.                 public boolean accept(File dir, String filename)  
  57.                 {  
  58.                     if (filename.endsWith(".jpg"))  
  59.                         return true;  
  60.                     return false;  
  61.                 }  
  62.             }));  
  63.             /** 
  64.              * 可以看到文件夹的路径和图片的路径分开保存,极大的减少了内存的消耗; 
  65.              */  
  66.             mAdapter = new MyAdapter(getApplicationContext(), mImgs,  
  67.                     mImgDir.getAbsolutePath());  
  68.             mGirdView.setAdapter(mAdapter);  
  69.         };  
  70.     };  
  71.   
  72.     @Override  
  73.     protected void onCreate(Bundle savedInstanceState)  
  74.     {  
  75.         super.onCreate(savedInstanceState);  
  76.         setContentView(R.layout.activity_main);  
  77.         mGirdView = (GridView) findViewById(R.id.id_gridView);  
  78.         getImages();  
  79.   
  80.     }  
  81.   
  82.     /** 
  83.      * 利用ContentProvider扫描手机中的图片,此方法在运行在子线程中 完成图片的扫描,最终获得jpg最多的那个文件夹 
  84.      */  
  85.     private void getImages()  
  86.     {  
  87.         if (!Environment.getExternalStorageState().equals(  
  88.                 Environment.MEDIA_MOUNTED))  
  89.         {  
  90.             Toast.makeText(this"暂无外部存储", Toast.LENGTH_SHORT).show();  
  91.             return;  
  92.         }  
  93.         // 显示进度条  
  94.         mProgressDialog = ProgressDialog.show(thisnull"正在加载...");  
  95.   
  96.         new Thread(new Runnable()  
  97.         {  
  98.   
  99.             @Override  
  100.             public void run()  
  101.             {  
  102.                 Uri mImageUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;  
  103.                 ContentResolver mContentResolver = MainActivity.this  
  104.                         .getContentResolver();  
  105.   
  106.                 // 只查询jpeg和png的图片  
  107.                 Cursor mCursor = mContentResolver.query(mImageUri, null,  
  108.                         MediaStore.Images.Media.MIME_TYPE + "=? or "  
  109.                                 + MediaStore.Images.Media.MIME_TYPE + "=?",  
  110.                         new String[] { "image/jpeg""image/png" },  
  111.                         MediaStore.Images.Media.DATE_MODIFIED);  
  112.   
  113.                 while (mCursor.moveToNext())  
  114.                 {  
  115.                     // 获取图片的路径  
  116.                     String path = mCursor.getString(mCursor  
  117.                             .getColumnIndex(MediaStore.Images.Media.DATA));  
  118.                     // 获取该图片的父路径名  
  119.                     File parentFile = new File(path).getParentFile();  
  120.                     String dirPath = parentFile.getAbsolutePath();   
  121.                       
  122.                     //利用一个HashSet防止多次扫描同一个文件夹(不加这个判断,图片多起来还是相当恐怖的~~)  
  123.                     if(mDirPaths.contains(dirPath))  
  124.                     {  
  125.                         continue;   
  126.                     }  
  127.                     else  
  128.                     {  
  129.                         mDirPaths.add(dirPath);  
  130.                     }  
  131.                       
  132.                     int picSize = parentFile.list(new FilenameFilter()  
  133.                     {  
  134.                         @Override  
  135.                         public boolean accept(File dir, String filename)  
  136.                         {  
  137.                             if (filename.endsWith(".jpg"))  
  138.                                 return true;  
  139.                             return false;  
  140.                         }  
  141.                     }).length;  
  142.                     if (picSize > mPicsSize)  
  143.                     {  
  144.                         mPicsSize = picSize;  
  145.                         mImgDir = parentFile;  
  146.                     }  
  147.                 }  
  148.                 mCursor.close();  
  149.                 //扫描完成,辅助的HashSet也就可以释放内存了  
  150.                 mDirPaths = null ;   
  151.                 // 通知Handler扫描图片完成  
  152.                 mHandler.sendEmptyMessage(0x110);  
  153.   
  154.             }  
  155.         }).start();  
  156.   
  157.     }  
  158. }  

MainActivity也是比较简单的,使用ContentProvider辅助,找到图片最多的文件夹后,直接handler去隐藏ProgressDialog,然后初始化数据,适配器等;

但是稍微注意一下:

1、在扫描图片时,使用了一个临时的HashSet保存扫描过的文件夹,这样可以有效的避免重复扫描。比如,我手机中有个文件夹下面有3000多张图片,如果不判断则会扫描这个文件夹3000多次,处理器时间以及内存的消耗还是很可观的。

2、在适配器中,保存List<String>的时候,考虑只保存图片的名称,路径单独作为变量传入。一般情况下,图片的路径比图片名长很多,加入有3000张图片,路径长度30,图片平均长度10,则List<String>保存完成路径需要长度为:(30+10)*3000 = 120000 ; 而单独存储只需要:30+10*3000 = 30030 ; 图片越多,节省的内存越客观;

总之,尽可能的去减少内存的消耗,这些都是很容易做到的~

3、GridView的适配器

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.example.zhy_handler_imageloader;  
  2.   
  3. import java.util.List;  
  4.   
  5. import android.content.Context;  
  6. import android.view.LayoutInflater;  
  7. import android.view.View;  
  8. import android.view.ViewGroup;  
  9. import android.widget.BaseAdapter;  
  10. import android.widget.ImageView;  
  11.   
  12. import com.zhy.utils.ImageLoader;  
  13.   
  14. public class MyAdapter extends BaseAdapter  
  15. {  
  16.   
  17.     private Context mContext;  
  18.     private List<String> mData;  
  19.     private String mDirPath;  
  20.     private LayoutInflater mInflater;  
  21.     private ImageLoader mImageLoader;  
  22.   
  23.     public MyAdapter(Context context, List<String> mData, String dirPath)  
  24.     {  
  25.         this.mContext = context;  
  26.         this.mData = mData;  
  27.         this.mDirPath = dirPath;  
  28.         mInflater = LayoutInflater.from(mContext);  
  29.   
  30.         mImageLoader = ImageLoader.getInstance();  
  31.     }  
  32.   
  33.     @Override  
  34.     public int getCount()  
  35.     {  
  36.         return mData.size();  
  37.     }  
  38.   
  39.     @Override  
  40.     public Object getItem(int position)  
  41.     {  
  42.         return mData.get(position);  
  43.     }  
  44.   
  45.     @Override  
  46.     public long getItemId(int position)  
  47.     {  
  48.         return position;  
  49.     }  
  50.   
  51.     @Override  
  52.     public View getView(int position, View convertView, final ViewGroup parent)  
  53.     {  
  54.         ViewHolder holder = null;  
  55.         if (convertView == null)  
  56.         {  
  57.             holder = new ViewHolder();  
  58.             convertView = mInflater.inflate(R.layout.grid_item, parent,  
  59.                     false);  
  60.             holder.mImageView = (ImageView) convertView  
  61.                     .findViewById(R.id.id_item_image);  
  62.             convertView.setTag(holder);  
  63.         } else  
  64.         {  
  65.             holder = (ViewHolder) convertView.getTag();  
  66.         }  
  67.         holder.mImageView  
  68.                 .setImageResource(R.drawable.friends_sends_pictures_no);  
  69.         //使用Imageloader去加载图片  
  70.         mImageLoader.loadImage(mDirPath + "/" + mData.get(position),  
  71.                 holder.mImageView);  
  72.         return convertView;  
  73.     }  
  74.   
  75.     private final class ViewHolder  
  76.     {  
  77.         ImageView mImageView;  
  78.     }  
  79.   
  80. }  

可以看到与传统的适配器的写法基本没有什么不同之处,甚至在getView里面都没有出现常见的回调(findViewByTag~用于防止图片的错位);仅仅多了一行代码:

mImageLoader.loadImage(mDirPath + "/" + mData.get(position),holder.mImageView);是不是用起来还是相当爽的,所有需要处理的细节都被封装了。

4、ImageLoader

现在才到了关键的时刻,我们封装的ImageLoader类,当然我们的异步消息处理机制也出现在其中。

首先是一个懒加载的单例

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /** 
  2.      * 单例获得该实例对象 
  3.      *  
  4.      * @return 
  5.      */  
  6.     public static ImageLoader getInstance()  
  7.     {  
  8.   
  9.         if (mInstance == null)  
  10.         {  
  11.             synchronized (ImageLoader.class)  
  12.             {  
  13.                 if (mInstance == null)  
  14.                 {  
  15.                     mInstance = new ImageLoader(1, Type.LIFO);  
  16.                 }  
  17.             }  
  18.         }  
  19.         return mInstance;  
  20.     }  

没啥说的,直接调用私有的构造方法,可以看到,默认传入了1(线程池中线程的数量),和LIFO(队列的工作方式)

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. private ImageLoader(int threadCount, Type type)  
  2.     {  
  3.         init(threadCount, type);  
  4.     }  
  5.   
  6.     private void init(int threadCount, Type type)  
  7.     {  
  8.         // loop thread  
  9.         mPoolThread = new Thread()  
  10.         {  
  11.             @Override  
  12.             public void run()  
  13.             {  
  14.                 try  
  15.                 {  
  16.                     // 请求一个信号量  
  17.                     mSemaphore.acquire();  
  18.                 } catch (InterruptedException e)  
  19.                 {  
  20.                 }  
  21.                 Looper.prepare();  
  22.   
  23.                 mPoolThreadHander = new Handler()  
  24.                 {  
  25.                     @Override  
  26.                     public void handleMessage(Message msg)  
  27.                     {  
  28.                         mThreadPool.execute(getTask());  
  29.                         try  
  30.                         {  
  31.                             mPoolSemaphore.acquire();  
  32.                         } catch (InterruptedException e)  
  33.                         {  
  34.                         }  
  35.                     }  
  36.                 };  
  37.                 // 释放一个信号量  
  38.                 mSemaphore.release();  
  39.                 Looper.loop();  
  40.             }  
  41.         };  
  42.         mPoolThread.start();  
  43.   
  44.         // 获取应用程序最大可用内存  
  45.         int maxMemory = (int) Runtime.getRuntime().maxMemory();  
  46.         int cacheSize = maxMemory / 8;  
  47.         mLruCache = new LruCache<String, Bitmap>(cacheSize)  
  48.         {  
  49.             @Override  
  50.             protected int sizeOf(String key, Bitmap value)  
  51.             {  
  52.                 return value.getRowBytes() * value.getHeight();  
  53.             };  
  54.         };  
  55.   
  56.         mThreadPool = Executors.newFixedThreadPool(threadCount);  
  57.         mPoolSemaphore = new Semaphore(threadCount);  
  58.         mTasks = new LinkedList<Runnable>();  
  59.         mType = type == null ? Type.LIFO : type;  
  60.   
  61.     }  

然后在私有构造里面调用了我们的init方法,在这个方法的开始就创建了mPoolThread这个子线程,在这个子线程中我们执行了Looper.prepare,初始化mPoolThreadHander,Looper.loop;如果看过上篇博客,一定知道,此时在这个子线程中维护了一个消息队列,且这个子线程会进入一个无限读取消息的循环中,而mPoolThreadHander这个handler发送的消息会直接发送至此线程中的消息队列。然后看mPoolThreadHander中handleMessage的方法,直接调用了getTask方法取出一个任务,然后放入线程池去执行。如果你比较细心,可能会发现里面还有一些信号量的操作的代码,如果你不了解什么是信号量,可以参考:Java 并发专题 : Semaphore 实现 互斥 与 连接池 。 简单说一下mSemaphore(信号数为1)的作用,由于mPoolThreadHander实在子线程初始化的,所以我在初始化前调用了mSemaphore.acquire去请求一个信号量,然后在初始化完成后释放了此信号量,我为什么这么做呢?因为在主线程可能会立即使用到mPoolThreadHander,但是mPoolThreadHander是在子线程初始化的,虽然速度很快,但是我也不能百分百的保证,主线程使用时已经初始化结束,为了避免空指针异常,所以我在主线程需要使用的时候,是这么调用的:

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /** 
  2.      * 添加一个任务 
  3.      *  
  4.      * @param runnable 
  5.      */  
  6.     private synchronized void addTask(Runnable runnable)  
  7.     {  
  8.         try  
  9.         {  
  10.             // 请求信号量,防止mPoolThreadHander为null  
  11.             if (mPoolThreadHander == null)  
  12.                 mSemaphore.acquire();  
  13.         } catch (InterruptedException e)  
  14.         {  
  15.         }  
  16.         mTasks.add(runnable);  
  17.         mPoolThreadHander.sendEmptyMessage(0x110);  
  18.     }  

如果mPoolThreadHander没有初始化完成,则会去acquire一个信号量,其实就是去等待mPoolThreadHander初始化完成。如果对此感兴趣的,可以将关于mSemaphore的代码注释,然后在初始化mPoolThreadHander使用Thread.sleep去暂停1秒,就会发现这样的错误。

初始化结束,就会在getView中调用mImageLoader.loadImage(mDirPath + "/" + mData.get(position),holder.mImageView);方法了,所以我们去看loadImage方法吧

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /** 
  2.      * 加载图片 
  3.      *  
  4.      * @param path 
  5.      * @param imageView 
  6.      */  
  7.     public void loadImage(final String path, final ImageView imageView)  
  8.     {  
  9.         // set tag  
  10.         imageView.setTag(path);  
  11.         // UI线程  
  12.         if (mHandler == null)  
  13.         {  
  14.             mHandler = new Handler()  
  15.             {  
  16.                 @Override  
  17.                 public void handleMessage(Message msg)  
  18.                 {  
  19.                     ImgBeanHolder holder = (ImgBeanHolder) msg.obj;  
  20.                     ImageView imageView = holder.imageView;  
  21.                     Bitmap bm = holder.bitmap;  
  22.                     String path = holder.path;  
  23.                     if (imageView.getTag().toString().equals(path))  
  24.                     {  
  25.                         imageView.setImageBitmap(bm);  
  26.                     }  
  27.                 }  
  28.             };  
  29.         }  
  30.   
  31.         Bitmap bm = getBitmapFromLruCache(path);  
  32.         if (bm != null)  
  33.         {  
  34.             ImgBeanHolder holder = new ImgBeanHolder();  
  35.             holder.bitmap = bm;  
  36.             holder.imageView = imageView;  
  37.             holder.path = path;  
  38.             Message message = Message.obtain();  
  39.             message.obj = holder;  
  40.             mHandler.sendMessage(message);  
  41.         } else  
  42.         {  
  43.             addTask(new Runnable()  
  44.             {  
  45.                 @Override  
  46.                 public void run()  
  47.                 {  
  48.   
  49.                     ImageSize imageSize = getImageViewWidth(imageView);  
  50.   
  51.                     int reqWidth = imageSize.width;  
  52.                     int reqHeight = imageSize.height;  
  53.   
  54.                     Bitmap bm = decodeSampledBitmapFromResource(path, reqWidth,  
  55.                             reqHeight);  
  56.                     addBitmapToLruCache(path, bm);  
  57.                     ImgBeanHolder holder = new ImgBeanHolder();  
  58.                     holder.bitmap = getBitmapFromLruCache(path);  
  59.                     holder.imageView = imageView;  
  60.                     holder.path = path;  
  61.                     Message message = Message.obtain();  
  62.                     message.obj = holder;  
  63.                     // Log.e("TAG", "mHandler.sendMessage(message);");  
  64.                     mHandler.sendMessage(message);  
  65.                     mPoolSemaphore.release();  
  66.                 }  
  67.             });  
  68.         }  
  69.   
  70.     }  

这段代码比较长,当然也是比较核心的代码了

10-29行:首先将传入imageView设置了path,然在初始化了一个mHandler用于设置imageView的bitmap,注意此时在UI线程,也就是这个mHandler发出的消息,会在UI线程中调用。可以看到在handleMessage中,我们从消息中取出ImageView,bitmap,path;然后将path与imageView的tag进行比较,防止图片的错位,最后设置bitmap;

31行:我们首先去从LruCache中去查找是否已经缓存了此图片

32-40:如果找到了,则直接使用mHandler去发送消息,这里使用了一个ImgBeanHolder去封装了ImageView,Bitmap,Path这三个对象。然后更新执行handleMessage代码去更新UI

43-66行:如果没有存在缓存中,则创建一个Runnable对象作为任务,去执行addTask方法加入任务队列

49行:getImageViewWidth根据ImageView获取适当的图片的尺寸,用于后面的压缩图片,代码按顺序贴下下面

54行:会根据计算的需要的宽和高,对图片进行压缩。代码按顺序贴下下面

56行:将压缩后的图片放入缓存

58-64行,创建消息,使用mHandler进行发送,更新UI

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /** 
  2.      * 根据ImageView获得适当的压缩的宽和高 
  3.      *  
  4.      * @param imageView 
  5.      * @return 
  6.      */  
  7.     private ImageSize getImageViewWidth(ImageView imageView)  
  8.     {  
  9.         ImageSize imageSize = new ImageSize();  
  10.         final DisplayMetrics displayMetrics = imageView.getContext()  
  11.                 .getResources().getDisplayMetrics();  
  12.         final LayoutParams params = imageView.getLayoutParams();  
  13.   
  14.         int width = params.width == LayoutParams.WRAP_CONTENT ? 0 : imageView  
  15.                 .getWidth(); // Get actual image width  
  16.         if (width <= 0)  
  17.             width = params.width; // Get layout width parameter  
  18.         if (width <= 0)  
  19.             width = getImageViewFieldValue(imageView, "mMaxWidth"); // Check  
  20.                                                                     // maxWidth  
  21.                                                                     // parameter  
  22.         if (width <= 0)  
  23.             width = displayMetrics.widthPixels;  
  24.         int height = params.height == LayoutParams.WRAP_CONTENT ? 0 : imageView  
  25.                 .getHeight(); // Get actual image height  
  26.         if (height <= 0)  
  27.             height = params.height; // Get layout height parameter  
  28.         if (height <= 0)  
  29.             height = getImageViewFieldValue(imageView, "mMaxHeight"); // Check  
  30.                                                                         // maxHeight  
  31.                                                                         // parameter  
  32.         if (height <= 0)  
  33.             height = displayMetrics.heightPixels;  
  34.         imageSize.width = width;  
  35.         imageSize.height = height;  
  36.         return imageSize;  
  37.   
  38.     }  

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /** 
  2.      * 根据计算的inSampleSize,得到压缩后图片 
  3.      *  
  4.      * @param pathName 
  5.      * @param reqWidth 
  6.      * @param reqHeight 
  7.      * @return 
  8.      */  
  9.     private Bitmap decodeSampledBitmapFromResource(String pathName,  
  10.             int reqWidth, int reqHeight)  
  11.     {  
  12.         // 第一次解析将inJustDecodeBounds设置为true,来获取图片大小  
  13.         final BitmapFactory.Options options = new BitmapFactory.Options();  
  14.         options.inJustDecodeBounds = true;  
  15.         BitmapFactory.decodeFile(pathName, options);  
  16.         // 调用上面定义的方法计算inSampleSize值  
  17.         options.inSampleSize = calculateInSampleSize(options, reqWidth,  
  18.                 reqHeight);  
  19.         // 使用获取到的inSampleSize值再次解析图片  
  20.         options.inJustDecodeBounds = false;  
  21.         Bitmap bitmap = BitmapFactory.decodeFile(pathName, options);  
  22.   
  23.         return bitmap;  
  24.     }  
接下来看AddTask的代码:

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /** 
  2.      * 添加一个任务 
  3.      *  
  4.      * @param runnable 
  5.      */  
  6.     private synchronized void addTask(Runnable runnable)  
  7.     {  
  8.         try  
  9.         {  
  10.             // 请求信号量,防止mPoolThreadHander为null  
  11.             if (mPoolThreadHander == null)  
  12.                 mSemaphore.acquire();  
  13.         } catch (InterruptedException e)  
  14.         {  
  15.         }  
  16.         mTasks.add(runnable);  
  17.         mPoolThreadHander.sendEmptyMessage(0x110);  
  18.     }  

可以看到,简单把任务放入任务队列,然后使用mPoolThreadHander发送一个消息到后台的loop中,后台的loop会取出消息执行:mThreadPool.execute(getTask());

execute执行的就是上面分析的Runnable中的run方法了。

注意一下:上述代码中还会看到mPoolSemaphore这个信号量的身影,说下用处;因为调用addTask之后,会直接去从任务队列取出一个任务,放入线程池,由于线程池内部其实也维持着一个队列,那么”从任务队列取出一个任务”这个动作会瞬间完成,直接加入线程池维护的队列中;这样会造成比如用户设置了调度队列为LIFO,但是由于”从任务队列取出一个任务”这个动作会瞬间完成,队列中始终维持在空队列的状态,所以让用户感觉LIFO根本没有效果;所以我按照用户设置线程池工作线程的数量设置了一个信号量,这样在保证任务执行完后,才会从任务队列去取任务,使得LIFO有着很好的效果;有兴趣的可以注释了所有的mPoolSemaphore代码,测试下就明白了。

到此代码基本介绍完毕。细节还是很多的,后面会附上源码,有兴趣的研究下代码,没有兴趣的,可以运行下代码,如果感觉流畅性不错,体验不错,可以作为工具类直接使用,使用也就getView里面一行代码。


贴一下效果图,我手机最多的文件夹大概3000张图片,加载速度还是相当相当流畅的:


真机录的,有点丢帧,注意看效果图,中间我疯狂拖动滚动条,但是图片基本还是瞬间显示的。

说一下,FIFO如果设置为这个模式,在控件中不做处理的话,用户拉的比较慢效果还是不错的,但是用户手机如果有个几千张,瞬间拉到最后,最后一屏图片的显示可能需要喝杯茶了~当然了,大家可以在控件中做处理,要么,拖动的时候不去加载图片,停在来再加载。或者,当手机抬起,给了一个很大的加速度,屏幕还是很快的滑动时停止加载,停下时加载图片。

LIFO这个模式可能用户体验会好很多,不管用户拉多块,最终停下来的那一屏图片都会瞬间显示~

最后掰一掰使用异步消息处理机制作为背后的子线程的好处,其实直接用一个子线程也可以实现,但是,这个子线程run中可能需要while(true)然后每隔200毫秒甚至更短的时间去查询任务队列是否有任务,没有则Thread.sleep,然后再去查询;这样如果长时间没有去添加任务,这个线程依然会不断的去查询;

而异步消息机制,只有在发送消息时才会去执行,当然更准确;当长时间没有任务到达时,也不会去查询,会一直阻塞在这;还有一点,这个机制Android内部实现的,怎么也比我们搞个Thread稳定性、效率高吧~


源码点击下载


转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38476887 ,本文出自【张鸿洋的博客】


相关文章推荐

Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38476887 ,本文出自【张鸿洋的博客】上一篇博客介绍了Android异步消息处...

Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38476887 ,本文出自【张鸿洋的博客】 最近创建了一个群,方便大家交流,...

Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

转自:http://blog.csdn.net/lmj623565791/article/details/38476887 ,本文出自【张鸿洋的博客】 最近创建了一个群,方便大家交流,群号:55...

Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

Android Handler 异步消息处理机制的妙用 创建强大的图片加载类 分类: 【android 进阶之路】 【Android 精彩案例】 【Android 源码解析】2014-0...
  • anlun
  • anlun
  • 2014-11-18 23:50
  • 275

Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38476887 ,本文出自【张鸿洋的博客】 很多人面试肯定都被问到过,请问A...

Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

上一篇博客介绍了Android异步消息处理机制,如果你还不了解,可以看:Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系 。那篇博客的最后,提出可...

(4.1.21.4)Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38476887 ,本文出自【张鸿洋的博客】 最近创建了一个群,方便大家交流,...

Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

最近创建了一个群,方便大家交流,群号:55032675 上一篇博客介绍了Android异步消息处理机制,如果你还不了解,可以看:Android 异步消息处理机制 让你深入理解 Looper、...

Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38476887 ,本文出自【张鸿洋的博客】 最近创建了一个群,方便大家交流,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)