【软引用】弱引用 图片的加载与缓存 OOM

在java.lang.ref包中提供了几个类：SoftReference类、WeakReference类和PhantomReference类，它们分别代表软引用、弱引用和虚引用。

ReferenceQueue类表示引用队列，它可以和这三种引用类联合使用，以便跟踪Java虚拟机回收所引用的对象的活动。

在Android应用的开发中，为了防止内存溢出，在处理一些占用内存大而且声明周期较长的对象时候，可以尽量应用软引用和弱引用技术。假设我们的应用会用到大量的默认图片，比如应用中有默认的头像，默认游戏图标等等，这些图片很多地方会用到。如果每次都去读取图片，由于读取文件需要硬件操作，速度较慢，会导致性能较低。所以我们考虑将图片缓存起来，需要的时候直接从内存中读取。但是，由于图片占用内存空间比较大，缓存很多图片需要很多的内存，就可能比较容易发生OutOfMemory异常。这时，我们可以考虑使用【软引用】技术来避免这个问题发生。使用软引用以后，在OutOfMemory异常发生之前，这些缓存的图片资源的内存空间可以被释放掉的，从而避免内存达到上限，避免Crash发生。

强引用   

Java从JDK1.2版本开始，就把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、【软引用】、弱引用和虚引用。

强引用其实相对而言非常的简单，也就是我们一般实例化对象后，对对象的一个引用就属于强引用，并且只要这个引用存在，那么GC（垃圾回收器）也就绝对不会去回收当前被引用的对象...如果将这个对象的引用设置为null，那么就代表GC可以对这个对象进行回收了...

软引用 SoftReference

如果一个对象只具有软引用，那么如果内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。

需要注意的是，在垃圾回收器对这个Java对象回收前，SoftReference类所提供的get方法会返回Java对象的强引用，一旦垃圾线程回收该Java对象之后，get方法将返回null。所以在获取软引用对象的代码中，一定要判断是否为null，以免出现NullPointerException导致应用崩溃。

软引用可用来实现内存敏感的高速缓存。

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

弱引用 WeakReference

如果一个对象只具有弱引用，那么在垃圾回收器线程扫描的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

弱引用与软引用的根本区别在于：只具有弱引用的对象拥有更短暂的生命周期，可能随时被回收；而只具有软引用的对象只有当内存不够的时候才被回收，在内存足够的时候，通常不被回收。

弱引用也可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

软引用与OOM
        软引用的使用是与【内存】挂钩的一个引用类，主要应用于内存敏感的高速缓存，其实在Android中是经常使用的到的，由于Android的虚拟机是基于寄存器的Dalvik，它的堆大小只有16M，我们都清楚无论是Android应用程序，还是Java应用程序，在实例化对象的时候都是在堆中完成的...因此在Android中这个堆的大小要求确实是很苛刻的，一旦我们读取的资源数据过大，或者是内存里的对象由于声明的周期太长，没有被及时的释放，那么就很有可能造成OOM的发生...我们都知道GC的回收机制在正常的情况下并不是时时刻刻都在工作的，它的工作时间是不定期的，因此如果在GC不工作的期间我们的内存已经爆表，那就必定导致OOM，OOM在Android是经常见到的一种情况，对象的不及时释放，static关键字的使用，线程不可控，还有最常见的就是在读取Bitmap的时候导致这种情况的发生...

       OOM是一个非常严重的问题，但是如果内存得不到充分的使用，这个其实也是一个潜在的问题，SoftReference（软引用），其实给我的感觉就是为了解决这样的问题，每一个对象通过软引用进行实例化，那么这个对象的数据也就会被保存起来，当需要再次调用这个对象中的数据的时候，只需要通过对象的get()方法就可以获取到该对象所保存的数据信息，其实也会是我们所说的cache，当内存快要不足的时候，GC会迅速的把所有的软引用清除掉，释放内存空间...这样不仅结合了对象的cache，同时还解决了OOM的发生，一举两得...虽然说是一举两得的东西，保证了内存能够安全的被使用，那么相反就要牺牲效率，在每一个软引用对象被实例化的时候，其实还是需要耗费许多的时间的...因此到底如何运用，取决于我们遇到的问题.

       在Android中，其实有一些时候还是由于Bitmap的问题导致内存不足的发生，图片相对而言还是比较大的，像素高的图片在读取的情况下是非常耗费内存的，如果读取的图片过多的话，那就更加的显而易见了，图片过多，内存会被吃的非常的紧，因此我们需要在Bitmap中去使用软引用，这样就可以避免OOM的发生...还可以有效的去使用内存...

示例代码
public class MainActivity extends ListActivity {
    private TextView tv_info;
    private ImageView imageView;
    public static final String BIG_IMAGE_PATH = Environment.getExternalStorageDirectory().getPath() + "/big.jpg";
    public static final String SMALL_IMAGE_PATH = Environment.getExternalStorageDirectory().getPath() + "/small.png";
    private Bitmap smallBitmap;
    private Bitmap bigBitmap;
    private Bitmap weakBitmap;
    //定义一个HashMap，保存软引用的Bitmap对象，可防止OOM
    private Map<String, SoftReference<Bitmap>> imageCaches = Collections.synchronizedMap(new HashMap<String, SoftReference<Bitmap>>());
    //弱引用可以在未被GC回收之前的获取到其中的Bitmap...一旦GC将其回收，那么就获取不到这个对象中的Bitmap了。该回收的时候，GC会自动的将其回收
    private WeakReference<Bitmap> weakReference;
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        String[] array = { "加载压缩后的大图到内存", "加载一张6000*8000(183M)的原图到内存", //
                "保存Bitmap的【SoftReference】到HashMap", "获得缓存到HashMap的Bitmap对象",//
                "保存Bitmap的【WeakReference】到HashMap", "获得WeakReference中的Bitmap对象", };
        setListAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, new ArrayList<String>(Arrays.asList(array))));
        tv_info = new TextView(this);
        tv_info.setTextColor(Color.BLUE);
        tv_info.setTextSize(TypedValue.COMPLEX_UNIT_SP, 16);
        tv_info.setPadding(20, 10, 20, 10);
        getListView().addFooterView(tv_info);
        imageView = new ImageView(this);
        getListView().addFooterView(imageView);
    }
    private int clickCount;
    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        clickCount++;
        if (clickCount % 2 == 0) {//大小图轮流显示
            smallBitmap = BitmapFactory.decodeFile(SMALL_IMAGE_PATH);
            imageView.setImageBitmap(smallBitmap);
            tv_info.setText(formatInfo(smallBitmap));
        } else {
            switch (position) {
            case 0:
                bigBitmap = decodeSampledBitmapFromFile(BIG_IMAGE_PATH, 1080, 1920);//每次都是重新加载的，从点击后响应速度就可以看得出来
                break;
            case 1:
                bigBitmap = BitmapFactory.decodeFile(BIG_IMAGE_PATH);//图片有多大就实际加载多大。第一次还能扛得住，但第二次点击时就会OOM
                break;
            case 2:
                addBitmapToCache(BIG_IMAGE_PATH);//只要第一次不OOM，以后点击（相当于替换掉旧的Bitmap）也都不会OOM
                return;//直接返回
            case 3:
                bigBitmap = getBitmapFromCache(BIG_IMAGE_PATH);//直接从缓存中取得，可以看到点击后响应非常快
                break;
            case 4:
                weakBitmap = BitmapFactory.decodeFile(BIG_IMAGE_PATH);
                weakReference = new WeakReference<Bitmap>(weakBitmap);//此后将weakBitmap置为null也不影响weakReference中的Bitmap
                return;//直接返回
            case 5:
                bigBitmap = weakReference.get();//同样响应非常快
                break;
            }
            if (bigBitmap != null) {
                imageView.setImageBitmap(bigBitmap);
                tv_info.setText(formatInfo(bigBitmap));
            } else Toast.makeText(this, "文件或缓存不存在", Toast.LENGTH_SHORT).show();
        }
    }
    private String formatInfo(Bitmap bitmap) {
        StringBuffer buffer = new StringBuffer();
        buffer.append("内存中bitmap的大小为：" + bitmap.getByteCount() + " = " + bitmap.getByteCount() / 1024 / 1024 + "M");
        buffer.append("
宽" + bitmap.getWidth() + " * 高" + bitmap.getHeight() + " * 参数" + 4 + " = " + bitmap.getWidth() * bitmap.getHeight() * 4);
        return buffer.toString();
    }
    /**按照指定的大小加载图片到内存，实际大小基本上不可能是指定的这个大小，因为图片会按照自己的规则进行缩放*/
    public Bitmap decodeSampledBitmapFromFile(String pathName, int reqWidth, int reqHeight) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(pathName, options);
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeFile(pathName, options);
    }
    /**在保证解析出的bitmap宽高分别大于目标尺寸宽高的前提下，取可能的inSampleSize的最大值*/
    public int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
        int width = options.outWidth;
        int height = options.outHeight;
        tv_info.setText("原始图片的宽高：" + width + "－" + height);//3600－5400
        int inSampleSize = 1;
        if (height > reqHeight || width > reqWidth) {
            int halfHeight = height / 2;
            int halfWidth = width / 2;
            while ((halfHeight / inSampleSize) > reqHeight && (halfWidth / inSampleSize) > reqWidth) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }
    /**添加软引用Bitmap到Map中，使其缓存*/
    public void addBitmapToCache(String path) {
        imageCaches.put(path, new SoftReference<Bitmap>(BitmapFactory.decodeFile(path)));
    }
    /** 从缓存中取软引用的Bitmap对象*/
    public Bitmap getBitmapFromCache(String path) {
        SoftReference<Bitmap> softBitmap = imageCaches.get(path);
        if (softBitmap != null) {//如果软引用还存在，那么直接就可以获取这个对象的相关数据...这样就实现了cache...
            return softBitmap.get();
        } else {//如果已经不存在，表示GC已经将其回收，我们需要重新实例化对象，获取数据信息（一般直接返回null）
            //addBitmapToCache(path);
            //return getBitmapFromCache(path);
            return null;
        }
    }
    public void clearCache() {
        imageCaches.clear();
    }
}