首页 > 编程语言 >使用LRU算法缓存图片,android 3.0

使用LRU算法缓存图片,android 3.0

时间:2022-11-29 15:07:39浏览次数:58  
标签:缓存 String bitmap LRU 内存 3.0 android Bitmap 图片


在您的UI中显示单个图片是非常简单的,如果您需要一次显示很多图片就有点复杂了。在很多情况下
(例如使用 ListView, GridView 或者 ​​​ViewPager​​​控件),
显示在屏幕上的图片以及即将显示在屏幕上的图片数量是非常大的(例如在图库中浏览大量图片)。

在这些控件中,当一个子控件不显示的时候,系统会重用该控件来循环显示 以便减少对内存的消耗。同时垃圾回收机制还会
释放那些已经载入内存中的Bitmap资源(假设您没有强引用这些Bitmap)。一般来说这样都是不错的,但是在用户来回滑动屏幕的时候,为了保证UI
的流畅性和载入图片的效率,您需要避免重复的处理这些需要显示的图片。 使用内存缓存和磁盘缓存可以解决这个问题,使用缓存可以让控件快速的加载已经处理过的图片。

这节内容介绍如何使用缓存来提高UI的载入输入和滑动的流畅性。


使用内存缓存

内存缓存提高了访问图片的速度,但是要占用不少内存。 ​​LruCache​​​ 类(在API 4之前可以使用​​Support Library​​ 中的类 )特别适合缓存Bitmap, 把最近使用到的
Bitmap对象用强引用保存起来(保存到​​LinkedHashMap​​中),当缓存数量达到预定的值的时候,把
不经常使用的对象删除。

注意: 过去,实现内存缓存的常用做法是使用
​​​SoftReference​​​ 或者
​​​WeakReference​​​ bitmap 缓存,
但是不推荐使用这种方式。从Android 2.3 (API Level 9) 开始,垃圾回收开始强制的回收掉 soft/weak 引用 从而导致这些缓存没有任何效率的提升。
另外,在 Android 3.0 (API Level 11)之前,这些缓存的Bitmap数据保存在底层内存(native memory)中,并且达到预定条件后也不会释放这些对象,从而可能导致
程序超过内存限制并崩溃。

在使用 ​​LruCache​​ 的时候,需要考虑如下一些因素来选择一个合适的缓存数量参数:

  • 程序中还有多少内存可用
  • 同时在屏幕上显示多少图片?要先缓存多少图片用来显示到即将看到的屏幕上?
  • 设备的屏幕尺寸和屏幕密度是多少?超高的屏幕密度(xhdpi 例如 ​​Galaxy Nexus​​)
    设备显示同样的图片要比低屏幕密度(hdpi 例如 ​​Nexus S​​)设备需要更多的内存。
  • 图片的尺寸和格式决定了每个图片需要占用多少内存
  • 图片访问的频率如何?一些图片的访问频率要比其他图片高很多?如果是这样的话,您可能需要把这些经常访问的图片放到内存中。
  • 在质量和数量上如何平衡?有些情况下保存大量的低质量的图片是非常有用的,当需要的情况下使用后台线程来加入一个高质量版本的图片。

这里没有万能配方可以适合所有的程序,您需要分析您的使用情况并在指定自己的缓存策略。使用太小的缓存并不能起到应有的效果,而使用太大的缓存会消耗更多
的内存从而有可能导致 java.lang.OutOfMemory 异常或者留下很少的内存供您的程序其他功能使用。

下面是一个使用 ​​LruCache​​ 缓存的示例:



[java]  ​​view plain​​ ​​copy​​



  1. private LruCache<string, bitmap=""> mMemoryCache;  
  2.                                                                 
  3. @Override  
  4. protected void onCreate(Bundle savedInstanceState) {  
  5.     ...  
  6. // Get memory class of this device, exceeding this amount will throw an  
  7. // OutOfMemory exception.  
  8. final int memClass = ((ActivityManager) context.getSystemService(  
  9.             Context.ACTIVITY_SERVICE)).getMemoryClass();  
  10.                                                                 
  11. // Use 1/8th of the available memory for this memory cache.  
  12. final int cacheSize = 1024 * 1024 * memClass / 8;  
  13.                                                                 
  14. new LruCache<string, bitmap="">(cacheSize) {  
  15. @Override  
  16. protected int sizeOf(String key, Bitmap bitmap) {  
  17. // The cache size will be measured in bytes rather than number of items.  
  18. return bitmap.getByteCount();  
  19.         }  
  20.     };  
  21.     ...  
  22. }  
  23.                                                                 
  24. public void addBitmapToMemoryCache(String key, Bitmap bitmap) {  
  25. if (getBitmapFromMemCache(key) == null) {  
  26.         mMemoryCache.put(key, bitmap);  
  27.     }  
  28. }  
  29.                                                                 
  30. public Bitmap getBitmapFromMemCache(String key) {  
  31. return mMemoryCache.get(key);  
  32. }  


注意: 在这个示例中,该程序的1/8内存都用来做缓存用了。在一个normal/hdpi设备中,这至少有4MB(32/8)内存。
在一个分辨率为 800×480的设备中,满屏的​​​GridView​​​全部填充上图片将会使用差不多1.5MB(800*480*4 bytes)
的内存,所以这样差不多在内存中缓存了2.5页的图片。

当在 ​​ImageView​​​ 中显示图片的时候,
先检查​​​LruCache​​ 中是否存在。如果存在就使用缓存后的图片,如果不存在就启动后台线程去载入图片并缓存:



[java]  ​​view plain​​ ​​copy​​



  1. public void loadBitmap(int resId, ImageView imageView) {  
  2. final String imageKey = String.valueOf(resId);  
  3.                                                        
  4. final Bitmap bitmap = getBitmapFromMemCache(imageKey);  
  5. if (bitmap != null) {  
  6.         mImageView.setImageBitmap(bitmap);  
  7. else {  
  8.         mImageView.setImageResource(R.drawable.image_placeholder);  
  9. new BitmapWorkerTask(mImageView);  
  10.         task.execute(resId);  
  11.     }  
  12. }  


​BitmapWorkerTask​​ 需要把新的图片添加到缓存中:


[java]  ​​view plain​​ ​​copy​​



  1. class BitmapWorkerTask extends AsyncTask<integer, void,="" bitmap=""> {  
  2.     ...  
  3. // Decode image in background.  
  4. @Override  
  5. protected Bitmap doInBackground(Integer... params) {  
  6. final Bitmap bitmap = decodeSampledBitmapFromResource(  
  7. 0], 100, 100));  
  8. 0]), bitmap);  
  9. return bitmap;  
  10.     }  
  11.     ...  
  12. }  




使用磁盘缓存

在访问最近使用过的图片中,内存缓存速度很快,但是您无法确定图片是否在缓存中存在。像
​​​GridView​​​ 这种控件可能具有很多图片需要显示,很快图片数据就填满了缓存容量。
同时您的程序还可能被其他任务打断,比如打进的电话 — 当您的程序位于后台的时候,系统可能会清楚到这些图片缓存。一旦用户恢复使用您的程序,您还需要重新处理这些图片。

在这种情况下,可以使用磁盘缓存来保存这些已经处理过的图片,当这些图片在内存缓存中不可用的时候,可以从磁盘缓存中加载从而省略了图片处理过程。
当然, 从磁盘载入图片要比从内存读取慢很多,并且应该在非UI线程中载入磁盘图片。

注意: 如果缓存的图片经常被使用的话,可以考虑使用
​​​ContentProvider​​ ,例如在图库程序中就是这样干滴。

在示例代码中有个简单的 DiskLruCache 实现。然后,在Android 4.0中包含了一个更加可靠和推荐使用的DiskLruCache(libcore/luni/src/main/java/libcore/io/DiskLruCache.java)
。您可以很容易的把这个实现移植到4.0之前的版本中使用(来 href="http://www.google.com/search?q=disklrucache">Google一下 看看其他人是否已经这样干了!)。

这里是一个更新版本的 DiskLruCache :



[java]  ​​view plain​​ ​​copy​​



  1. private DiskLruCache mDiskCache;  
  2. private static final int DISK_CACHE_SIZE = 1024 * 1024 * 10; // 10MB  
  3. private static final String DISK_CACHE_SUBDIR = "thumbnails";  
  4.                                  
  5. @Override  
  6. protected void onCreate(Bundle savedInstanceState) {  
  7.     ...  
  8. // Initialize memory cache  
  9.     ...  
  10. this, DISK_CACHE_SUBDIR);  
  11. this, cacheDir, DISK_CACHE_SIZE);  
  12.     ...  
  13. }  
  14.                                  
  15. class BitmapWorkerTask extends AsyncTask<integer, void,="" bitmap=""> {  
  16.     ...  
  17. // Decode image in background.  
  18. @Override  
  19. protected Bitmap doInBackground(Integer... params) {  
  20. final String imageKey = String.valueOf(params[0]);  
  21.                                  
  22. // Check disk cache in background thread  
  23.         Bitmap bitmap = getBitmapFromDiskCache(imageKey);  
  24.                                  
  25. if (bitmap == null) { // Not found in disk cache  
  26. // Process as normal  
  27. final Bitmap bitmap = decodeSampledBitmapFromResource(  
  28. 0], 100, 100));  
  29.         }  
  30.                                  
  31. // Add final bitmap to caches  
  32.         addBitmapToCache(String.valueOf(imageKey, bitmap);  
  33.                                  
  34. return bitmap;  
  35.     }  
  36.     ...  
  37. }  
  38.                                  
  39. public void addBitmapToCache(String key, Bitmap bitmap) {  
  40. // Add to memory cache as before  
  41. if (getBitmapFromMemCache(key) == null) {  
  42.         mMemoryCache.put(key, bitmap);  
  43.     }  
  44.                                  
  45. // Also add to disk cache  
  46. if (!mDiskCache.containsKey(key)) {  
  47.         mDiskCache.put(key, bitmap);  
  48.     }  
  49. }  
  50.                                  
  51. public Bitmap getBitmapFromDiskCache(String key) {  
  52. return mDiskCache.get(key);  
  53. }  
  54.                                  
  55. // Creates a unique subdirectory of the designated app cache directory. Tries to use external  
  56. // but if not mounted, falls back on internal storage.  
  57. public static File getCacheDir(Context context, String uniqueName) {  
  58. // Check if media is mounted or storage is built-in, if so, try and use external cache dir  
  59. // otherwise use internal cache dir  
  60. final String cachePath = Environment.getExternalStorageState() == Environment.MEDIA_MOUNTED  
  61.             || !Environment.isExternalStorageRemovable() ?  
  62.                     context.getExternalCacheDir().getPath() : context.getCacheDir().getPath();  
  63.                                  
  64. return new File(cachePath + File.separator + uniqueName);  
  65. }  


在UI线程中检测内存缓存,在后台线程中检测磁盘缓存。磁盘操作从来不应该在UI线程中实现。当图片处理完毕后,最终的结果会同时添加到
内存缓存和磁盘缓存中以便将来使用。


处理配置改变事件

运行时的配置变更 — 例如 屏幕方向改变 — 导致Android摧毁正在运行的Activity,然后使用
新的配置从新启动该Activity (详情,参考这里 ​​​Handling Runtime Changes​​​)。
您需要注意避免在配置改变的时候导致重新处理所有的图片,从而提高用户体验。

幸运的是,您在 ​​使用内存缓存​​​ 部分已经有一个很好的图片缓存了。该缓存可以通过
​​​Fragment​​​ (Fragment会通过​​setRetainInstance(true)​​​函数保存起来)来传递给新的Activity
当Activity重新启动 后,Fragment 被重新附加到Activity中,您可以通过该Fragment来获取缓存对象。

下面是一个在 Fragment中保存缓存的示例:



[java]  ​​view plain​​ ​​copy​​



  1. private LruCache<string, bitmap=""> mMemoryCache;  
  2.                    
  3. @Override  
  4. protected void onCreate(Bundle savedInstanceState) {  
  5.     ...  
  6.     RetainFragment mRetainFragment =  
  7.             RetainFragment.findOrCreateRetainFragment(getFragmentManager());  
  8.     mMemoryCache = RetainFragment.mRetainedCache;  
  9. if (mMemoryCache == null) {  
  10. new LruCache<string, bitmap="">(cacheSize) {  
  11. // Initialize cache here as usual  
  12.         }  
  13.         mRetainFragment.mRetainedCache = mMemoryCache;  
  14.     }  
  15.     ...  
  16. }  
  17.                    
  18. class RetainFragment extends Fragment {  
  19. private static final String TAG = "RetainFragment";  
  20. public LruCache<string, bitmap=""> mRetainedCache;  
  21.                    
  22. public RetainFragment() {}  
  23.                    
  24. public static RetainFragment findOrCreateRetainFragment(FragmentManager fm) {  
  25.         RetainFragment fragment = (RetainFragment) fm.findFragmentByTag(TAG);  
  26. if (fragment == null) {  
  27. new RetainFragment();  
  28.         }  
  29. return fragment;  
  30.     }  
  31.                    
  32. @Override  
  33. public void onCreate(Bundle savedInstanceState) {  
  34. super.onCreate(savedInstanceState);  
  35. true);</strong>  
  36.     }  
  37. }  



您可以尝试分别使用和不使用Fragment来旋转设备的屏幕方向来查看具体的图片载入情况。

标签:缓存,String,bitmap,LRU,内存,3.0,android,Bitmap,图片
From: https://blog.51cto.com/u_13657808/5895096

相关文章

  • android viewgroup事件分发机制
    1、案例首先我们接着上一篇的代码,在代码中添加一个自定义的LinearLayout:[java]​​viewplain​​​​copy​​package  importimportimportimportimpor......
  • android混淆
    为了防止自己的劳动成果被别人窃取,混淆代码能有效防止被反编译,下面来总结以下混淆代码的步骤:1.大家也许都注意到新建一个工程会看到项目下边有这样proguard-project.txt......
  • android自定义view实现progressbar的效果
    一键清理是很多Launcher都会带有的功能,其效果也比较美观。实现方式也许有很多中,其中常见的是使用图片drawable来完成的,具体可以参考这篇文章:​​模仿......
  • android studio添加project libs库步骤
    在Eclipse中选择要导出的项目,然后依次选择菜单file->export->Android->GenerateGradlebuild files.之后依次点击next到finish即可回到Androidstudio打开settin......
  • android守护进程
    Service组件在android开发中经常遇到,其经常作为后台服务,需要始终保持运行,负责处理一些必要(见不得人)的任务。而一些安全软件,如360等,会有结束进程的功能,如果不做Service的保持......
  • android上拉下拉加载更多数据
    效果图下拉刷新:加载更多:CustomListView.java[java]​​viewplain​​​​copy​​package  importimportimportimportimportimportimportimportimporti......
  • android多屏幕分辨率适配
    首先要介绍一下drawable-mdpi、drawable-hdpi-1280x800、drawable-hdpi。这个相信好好看一下也明白。就是代表着分辨率320X480、1280X800、480X800三款屏幕图片资源包。其......
  • android 之ndk开发
    1、AndroidNDK简介NDK全称为nativedevelopmentkit本地语言(C&C++)开发包。而对应的是经常接触的Android-SDK,(softwaredevelopmentkit)软件开发包(只支持java语言开发)。简单......
  • android之service
    android中服务是运行在后台的东西,级别与activity差不多。既然说service是运行在后台的服务,那么它就是不可见的,没有界面的东西。你可以启动一个服务Service来播放音乐,或者记......
  • android代码混淆
    proguard原理Java代码编译成二进制class文件,这个class文件也可以反编译成源代码,除了注释外,原来的code基本都可以看到。为了防止重要code被泄......