Android教程網
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> 關於Android編程 >> Android 內存緩存 LruCache

Android 內存緩存 LruCache

編輯:關於Android編程

關於的圖片緩存官方文檔:

https://developer.android.com/training/displaying-bitmaps/cache-bitmap.html#memory-cache

在你的應用程序的UI界面加載一張圖片是一件很簡單的事情,但是當你需要在界面上加載一大堆圖片的時候,情況就變得復雜起來。在很多情況下,(比如使用ListView, GridView 或者 ViewPager 這樣的組件),屏幕上顯示的圖片可以通過滑動屏幕等事件不斷地增加,最終會導致OOM。

為了保證內存的使用始終維持在一個合理的范圍,通常會把被移除屏幕的圖片進行回收處理。此時垃圾回收器也會認為你不再持有這些圖片的引用,從而對這些圖片進行GC操作。用這種思路來解決問題是非常好的,可是為了能讓程序快速運行,在界面上迅速地加載圖片,你又必須要考慮到某些圖片被回收之後,用戶又將它重新滑入屏幕這種情況。這時重新去加載一遍剛剛加載過的圖片無疑是性能的瓶頸,你需要想辦法去避免這個情況的發生。這個時候,使用內存緩存和磁盤緩存可以很好的解決這個問題,它可以讓組件快速地重新加載和處理圖片。

首先來看一下內存緩存:

 

內存緩存提供對圖片的快速訪問,其代價是占用應用程序的寶貴內存。其中最核心的類是LruCache (android-support-v4也有,兼容到level4) 。這個類非常適合用來緩存圖片,它的主要算法原理是把最近使用的對象用強引用存儲在 LinkedHashMap 中,並且把最近最少使用的對象在緩存值達到預設定值之前從內存中移除。

在過去,我們經常會使用一種非常流行的內存緩存技術的實現,即軟引用或弱引用 (SoftReference or WeakReference)。但是現在已經不再推薦使用這種方式了,因為從 Android 2.3 (API Level 9)開始,垃圾回收器會更傾向於回收持有軟引用或弱引用的對象,這讓軟引用和弱引用變得不再可靠。另外,Android 3.0 (API Level 11)之前,圖片的數據會存儲在本地的內存當中,因而無法用一種可預見的方式將其釋放,從而可能導致應用程序短暫超過其內存限制而崩潰。

為了能夠選擇一個合適的緩存大小給LruCache, 有以下多個因素應該放入考慮范圍內,例如:

你的設備可以為每個應用程序分配多大的內存?設備屏幕上一次最多能顯示多少張圖片?有多少圖片需要進行預加載,因為有可能很快也會顯示在屏幕上?你的設備的屏幕大小和分辨率分別是多少?一個超高分辨率的設備(例如 Galaxy Nexus) 比起一個較低分辨率的設備(例如 Nexus S),在持有相同數量圖片的時候,需要更大的緩存空間。圖片的尺寸和大小,還有每張圖片會占據多少內存空間。圖片被訪問的頻率有多高?會不會有一些圖片的訪問頻率比其它圖片要高?如果有的話,你也許應該讓一些圖片常駐在內存當中,或者使用多個LruCache 對象來區分不同組的圖片。你能維持好數量和質量之間的平衡嗎?有些時候,存儲多個低像素的圖片,而在後台去開線程加載高像素的圖片會更加的有效。

並沒有一個指定的緩存大小可以滿足所有的應用程序,這是由你決定的。你應該去分析程序內存的使用情況,然後制定出一個合適的解決方案。一個太小的緩存空間,有可能造成圖片頻繁地被釋放和重新加載,這並沒有好處。而一個太大的緩存空間,則有可能還是會引起Java.lang.OutOfMemory 的異常。

下面就看一個demo,如何使用LruCache:

 

package cj.com.memorycache;

import android.annotation.TargetApi;
import android.app.ActivityManager;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Build;
import android.support.v4.util.LruCache;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;

import java.lang.ref.WeakReference;

public class MainActivity extends AppCompatActivity {
    private LruCache mMemoryCache;
    private ImageView image;
    private final static String TAG = "memorycache";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        image = (ImageView) findViewById(R.id.imageView);

        int memoryCacheSize = 0;
        ActivityManager activityManager = (ActivityManager) this.getSystemService(Context.ACTIVITY_SERVICE);
        int memoryClass = activityManager.getMemoryClass();
        if(hasHoneycomb()&&isLargeHeap(this)){
            memoryClass = activityManager.getLargeMemoryClass();
        }
        memoryCacheSize = (memoryClass*1024*1024)/8;//八分之一的內存作為內存緩存 單位是byte

        Log.d(TAG,"memoryCacheSize="+memoryCacheSize);

        mMemoryCache = new LruCache(memoryCacheSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getByteCount();
            }
        };

    }
    public void click(View v){
        Log.d(TAG,"click");
        loadBitmap(R.drawable.bigwheel,image);
    }

    private  boolean hasHoneycomb() {
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB;
    }


    private static boolean isLargeHeap(Context context) {
        return (context.getApplicationInfo().flags & ApplicationInfo.FLAG_LARGE_HEAP) != 0;
    }

    public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
        Log.d(TAG,"addBitmapToMemoryCache");
        if (getBitmapFromMemCache(key) == null) {
            Log.d(TAG,"memorycache has no this bitmap");
            mMemoryCache.put(key, bitmap);
        }
    }

    public Bitmap getBitmapFromMemCache(String key) {
        return mMemoryCache.get(key);
    }

    public void loadBitmap(int resId, ImageView imageView) {
        final String imageKey = String.valueOf(resId);

        final Bitmap bitmap = getBitmapFromMemCache(imageKey);
        if (bitmap != null) {
            Log.d(TAG,"bitmap has in memorycache");
            imageView.setImageBitmap(bitmap);
        } else {
            Log.d(TAG,"bitmap is not in memorycache");
            imageView.setImageResource(R.mipmap.ic_launcher);
            BitmapWorkerTask task = new BitmapWorkerTask(imageView);
            task.execute(resId);
        }
    }

    class BitmapWorkerTask extends AsyncTask {
        private final WeakReference imageViewReference;
        private int data = 0;

        public BitmapWorkerTask(ImageView imageView) {
            // Use a WeakReference to ensure the ImageView can be garbage collected
            imageViewReference = new WeakReference(imageView);
        }

        // Decode image in background.
        @Override
        protected Bitmap doInBackground(Integer... params) {
            data = params[0];
            Bitmap bitmap = decodeSampledBitmapFromResource(getResources(), data, 100, 100);
            if(bitmap != null){
                addBitmapToMemoryCache(String.valueOf(data),bitmap);
                return bitmap;
            }
            return null;
        }

        // Once complete, see if ImageView is still around and set bitmap.
        @Override
        protected void onPostExecute(Bitmap bitmap) {
            if (imageViewReference != null && bitmap != null) {
                final ImageView imageView = imageViewReference.get();
                if (imageView != null) {
                    imageView.setImageBitmap(bitmap);
                }
            }
        }
    }

    private Bitmap decodeSampledBitmapFromResource(Resources res , int resId, int targetWidth, int tartgetHegiht){
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        Bitmap bitmap = BitmapFactory.decodeResource(res, resId, options);

        options.inSampleSize = calculateInSampleSize(options, targetWidth, tartgetHegiht);
        options.inJustDecodeBounds = false;
        return  BitmapFactory.decodeResource(res, resId, options);
    }

    private int calculateInSampleSize(
            BitmapFactory.Options options, int reqWidth, int reqHeight) {
        final int height = options.outHeight;
        final int width = options.outWidth;
        String imageType = options.outMimeType;
        int inSampleSize = 1;
        if (height > reqHeight || width > reqWidth) {
            final int halfHeight = height / 2;
            final int halfWidth = width / 2;
            while ((halfHeight / inSampleSize) >= reqHeight
                    && (halfWidth / inSampleSize) >= reqWidth) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }

}

demo做的事情就是加載本地一張圖片(沒去加載網絡圖片了),加載的時首先去內存緩存獲取看是否已經在內存緩存中了,如果已經在了,直接取回來,否則就使用AsyncTask去加載圖片,將獲得圖片存入緩存,下次再次去加載這張圖片時,就直接在緩存裡面獲取了。

 

 

 int memoryCacheSize = 0;
        ActivityManager activityManager = (ActivityManager) this.getSystemService(Context.ACTIVITY_SERVICE);
        int memoryClass = activityManager.getMemoryClass();
        if(hasHoneycomb()&&isLargeHeap(this)){
            memoryClass = activityManager.getLargeMemoryClass();
        }
        memoryCacheSize = (memoryClass*1024*1024)/8;//八分之一的內存作為內存緩存 單位是byte

        Log.d(TAG,"memoryCacheSize="+memoryCacheSize);

這篇文章已經提到了。

 

 mMemoryCache = new LruCache(memoryCacheSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getByteCount();
            }
        };
創建內存緩存對象LruCache,傳入的參數就是內存緩存的大小,重寫sizeOf函數,返回的該圖片的字節數。

 

 

public void click(View v){
        Log.d(TAG,"click");
        loadBitmap(R.drawable.bigwheel,image);
    }

點擊button就去加載圖片

 

 

public void loadBitmap(int resId, ImageView imageView) {
        final String imageKey = String.valueOf(resId);

        final Bitmap bitmap = getBitmapFromMemCache(imageKey);
        if (bitmap != null) {
            Log.d(TAG,"bitmap has in memorycache");
            imageView.setImageBitmap(bitmap);
        } else {
            Log.d(TAG,"bitmap is not in memorycache");
            imageView.setImageResource(R.mipmap.ic_launcher);
            BitmapWorkerTask task = new BitmapWorkerTask(imageView);
            task.execute(resId);
        }
    }

public Bitmap getBitmapFromMemCache(String key) {
        return mMemoryCache.get(key);
    }

首先就去內存緩存去查找是否有該張圖片,如果有就直接用了,否則就啟動AsyncTask去加載

 

 

class BitmapWorkerTask extends AsyncTask {
        private final WeakReference imageViewReference;
        private int data = 0;

        public BitmapWorkerTask(ImageView imageView) {
            // Use a WeakReference to ensure the ImageView can be garbage collected
            imageViewReference = new WeakReference(imageView);
        }

        // Decode image in background.
        @Override
        protected Bitmap doInBackground(Integer... params) {
            data = params[0];
            Bitmap bitmap = decodeSampledBitmapFromResource(getResources(), data, 100, 100);
            if(bitmap != null){
                addBitmapToMemoryCache(String.valueOf(data),bitmap);
                return bitmap;
            }
            return null;
        }

        // Once complete, see if ImageView is still around and set bitmap.
        @Override
        protected void onPostExecute(Bitmap bitmap) {
            if (imageViewReference != null && bitmap != null) {
                final ImageView imageView = imageViewReference.get();
                if (imageView != null) {
                    imageView.setImageBitmap(bitmap);
                }
            }
        }
    }

加載圖片的過程

 

decodeSampledBitmapFromResource()

 

加載完成後,將圖片添加到內存緩存中

 

 if(bitmap != null){
                addBitmapToMemoryCache(String.valueOf(data),bitmap);
                return bitmap;
            }

 public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
        Log.d(TAG,"addBitmapToMemoryCache");
        if (getBitmapFromMemCache(key) == null) {
            Log.d(TAG,"memorycache has no this bitmap");
            mMemoryCache.put(key, bitmap);
        }
    }

當再一次點擊button去加載圖片時,就直接從內存緩存中獲取了

 

看一下log:

 

D/memorycache: memoryCacheSize=50331648
D/OpenGLRenderer: Render dirty regions requested: true

                  [ 10-18 08:03:48.339  3055: 3055 D/         ]
                  HostConnection::get() New Host Connection established 0x7feda1de3900, tid 3055
D/Atlas: Validating map...

         [ 10-18 08:03:48.410  3055: 3148 D/         ]
         HostConnection::get() New Host Connection established 0x7feda4433180, tid 3148
I/OpenGLRenderer: Initialized EGL, version 1.4
D/OpenGLRenderer: Enabling debug mode 0
D/memorycache: click
D/memorycache: bitmap is not in memorycache
D/memorycache: addBitmapToMemoryCache
D/memorycache: memorycache has no this bitmap
D/memorycache: click
D/memorycache: bitmap has in memorycache
Application terminated.

通過以上log可以驗證,內存緩存成功了。
  1. 上一頁:
  2. 下一頁:
熱門文章
閱讀排行版
Copyright © Android教程網 All Rights Reserved