1、什么是OOM？
程序申请内存过大，虚拟机无法满足我们，然后自杀了。这个现象通常出现在大图片的APP开发，或者需要用到很多图片的时候。通俗来讲就是我们的APP需要申请一块内存来存放图片的时候，系统认为我们的程序需要的内存过大，及时系统有充分的内存，比如1G，但是系统也不会分配给我们的APP，故而抛出OOM异常，程序没有捕捉异常，故而弹窗崩溃了
2、为什么会有OOM？
因为Android系统的APP每个进程或者虚拟机有最大内存限制，一旦超过这个限制系统就会抛出OOM错误。跟手机剩余内存是否充足没有多少关系。
3、为什么Android会有APP的内存限制
(1)要开发者使用内存更加合理。限制每个应用可用内存上限，避免恶意程序或单个程序使用过多内存导致其他程序的不可运行。有了限制，开发者就必须合理使用资源，优化资源使用
(2)屏幕显示内容有限，内存足够即可。即使有万千图片千万数据需要使用到，但在特定时刻需要展示给用户看的总是有限的，因为屏幕显示就那么大，上面可以放的信息就是很有限的。大部分信息都是处于准备显示状态，所以没必要给予太多heap内存。必须一个ListView显示图片，打个比方这个ListView含有500个item，但是屏幕显示最多有10调item显示，其余数据是处于准备显示状态。
(3)Android多个虚拟机Davlik的限制需要。android设备上的APP运行，每打开一个应用就会打开至少一个独立虚拟机。这样可以避免系统崩溃，但代价是浪费更多内存。
4、有GC自动回收资源，为什么还会有OOM？
Android的GC会按照特定的算法来回收不使用的资源，但是gc一般回收的是无主的对象内存或者软引用资源。
使用软引用的图片资源在一定程度上可以避免OOM。
ps：不用的对象设置为null，是一个好习惯。不过更好的方法是，不用的图片直接recycle。因为有时候通过设置null让gc来回收还是来不及。
5、怎么来避免OOM产生呢？
简单通过SoftReference引用方式管理图片资源
建一个SoftReference的hashmap，使用图片时，先检查这个hashmap是否有softreference，softreference的图片是否为空，如果为空将图片加载到softreference并加入haspmap。
代码如下：

import java.io.InputStream;  
import java.lang.ref.SoftReference;  
import java.net.HttpURLConnection;  
import java.net.URL;  
import java.net.URLConnection;  
import java.util.HashMap;  
import android.content.Context;  
import android.graphics.Bitmap;  
import android.graphics.BitmapFactory;  
import android.os.Handler;  
import android.os.Handler.Callback;  
import android.os.Message;  
import android.widget.ImageView;  
  
  
/** 
 * 功能说明：异步加载图片 
 * 
 */  
  
public class AsyncImageLoaderCore {  
    public Context context; // 做本地缓存时会用到  
    public HashMap<String, SoftReference<Bitmap>> imageCache;// 软引用集合  
     
    public AsyncImageLoaderCore(Context context) {  
        this.context = context;  
        this.imageCache = new HashMap<String, SoftReference<Bitmap>>();  
    }  
  
  
    public Bitmap loadBitmap(final String imageUrl, final ImageView imageView, final ImageCallback imageCallback) {  
        if (imageCache.containsKey(imageUrl)) {  
            SoftReference<Bitmap> softReference = imageCache.get(imageUrl);  
            if (softReference.get() != null)  
                return softReference.get();  
        }  
          
        final Handler handler = new Handler(new Callback() {  
            @Override  
            public boolean handleMessage(Message msg) {  
                imageCallback.imageLoaded((Bitmap) msg.obj, imageView, imageUrl);  
                return false;  
            }  
        });  
          
        new Thread() {  
            @Override  
            public void run() {  
                Bitmap bitmap = null;  
                try {  
                    bitmap = getHttpBitmap(imageUrl);  
                } catch (Exception e) {  
                    e.printStackTrace();  
                    return;  
                }  
                  
                if (null != bitmap) {  
                    imageCache.put(imageUrl, new SoftReference<Bitmap>(bitmap));  
                    handler.sendMessage(handler.obtainMessage(0, bitmap));  
                }  
            }  
        }.start();  
        return null;  
    }  
    private final int MAX_PIC_LENGTH = 200000;// 最大字节长度限制[可调,最好不要超过200000]  
    private final int SAMPLE_SIZE = 14;// 裁剪图片比列(1/14)[可调]  
    /** 
     * 获取网络图片 
     */  
    private Bitmap getHttpBitmap(String imgUrl) throws Exception {  
        URL htmlUrl = new URL(imgUrl);  
        URLConnection connection = htmlUrl.openConnection();  
        HttpURLConnection conn = (HttpURLConnection) connection;  
        if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {  
            InputStream inputStream = conn.getInputStream();  
            byte[] bytes = changeToBytes(inputStream);  
            if (bytes.length < MAX_PIC_LENGTH) {  
                return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);  
            } else if (bytes.length < MAX_PIC_LENGTH * SAMPLE_SIZE) {  
                BitmapFactory.Options options = new BitmapFactory.Options();  
                options.inJustDecodeBounds = false;  
                options.inSampleSize = SAMPLE_SIZE;  
                return BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);  
            }  
        }  
        return null;  
    }  
  
  
    /** 
     * 将流转换成字节数组 
     */  
  
    public byte[] changeToBytes(InputStream inputStream) throws Exception  
    {  
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();  
        byte[] buffer = new byte[1024];// 每次读取的字节长度  
        int len = 0;  
        while ((len = inputStream.read(buffer)) != -1)  
        {  
            outputStream.write(buffer, 0, len);  
        }  
        inputStream.close();  
        return outputStream.toByteArray();  
    }  
    /** 
     * 异步加载资源回调接口 
     */  
    public interface ImageCallback {  
        public void imageLoaded(Bitmap bitmap, ImageView imageView, String imageUrl);  
    }  
}  ```