另辟蹊径——Android内存优化

研究这个是因为要在单独进程中启动一个service，而这个service的内存占用有严格限制，经过研究发现内存占用中很大一部分是preloadedResources，而service是后台运行无需界面的，所以这块内存可以清理掉。系统没有提供现成的接口，所以需要通过反射实现。

首先，我们做一个实验来验证效果：

public class MainActivity extends Activity {

    private Button mBtnStart;
    private Button mBtnStop;
    private Button mBtnClear;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mBtnStart = (Button) findViewById(R.id.start);
        mBtnStop = (Button) findViewById(R.id.stop);
        mBtnClear = (Button) findViewById(R.id.clear);

        mBtnStart.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                Intent startIntent = new Intent(MainActivity.this,
                        MyService.class);
                startService(startIntent);
            }
        });

        mBtnStop.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                Intent stopIntent = new Intent(MainActivity.this,
                        MyService.class);
                stopService(stopIntent);
            }
        });

        mBtnClear.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                sendBroadcast();
            }
        });
    }

    private void sendBroadcast() {
        Intent intent = new Intent("com.example.clear");
        this.sendBroadcast(intent);
    }
}

这里有三个按钮，分别是启动service，停止service，和清理service的preloaded resource。再来看看service的实现：

public class MyService extends Service {

    @Override
    public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        Log.i("bush", "service onCreate");

        IntentFilter filter = new IntentFilter("com.example.clear");
        registerReceiver(mReceiver, filter);
    }

    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {

        @Override
        public void onReceive(Context context, Intent intent) {
            // TODO Auto-generated method stub
            PreloadClearUtil.clearResources();
            Log.i("bush", "service onReceive");
        }
    };

    @Override
    public void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        Log.i("bush", "service onDestroy");

        unregisterReceiver(mReceiver);
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        return null;
    }

}

这里面什么也没有做，只是接收清理资源的广播而已，service运行在单独的进程中。我们启动app，点击start service按钮，发现DDMS中多出来一个进程，如下：

我们选中service所在的进程，Update Heap，并GC一下，查看内存占用情况

这里可见我们的service里什么也没有，内存却占用了约23M。我们Dump Hprof File，如下：

可见这些内存主要是sPreloadedDrawables持有，而且都是强引用。

我们清理一下这些preloadedDrawables，再查看内存占用情况，如下：

可见这回内存只占用3M左右，大部分都是必须加载的Class和String资源了。

接下来，我们再看看这些preloadedDrawables是什么时候加载的。

Zygote启动时会调用ZygoteInit的main函数，其中会通过preloadResources()来预加载资源，而之后所有的android应用进程都是从Zygote fork出来的，所以就继承了这部分预加载的资源，包括独立的Service进程。

private static void preloadResources() {
    final VMRuntime runtime = VMRuntime.getRuntime();
    mResources = Resources.getSystem();
    mResources.startPreloading();
    if (PRELOAD_RESOURCES) {
        TypedArray ar = mResources.obtainTypedArray(
                com.android.internal.R.array.preloaded_drawables);
        int N = preloadDrawables(runtime, ar);
        ar = mResources.obtainTypedArray(
                com.android.internal.R.array.preloaded_color_state_lists);
        N = preloadColorStateLists(runtime, ar);
    }
    mResources.finishPreloading();
}

private static final boolean PRELOAD_RESOURCES = true;

这里依次预加载Drawables和ColorStateLists。是否预加载的开关PRELOAD_RESOURCES默认是打开的。
预加载的资源在com.android.internal.R.array.preloaded_drawables中声明。接下来我们看看preloadDrawables的实现，如下：

private static int preloadDrawables(VMRuntime runtime, TypedArray ar) {
    int N = ar.length();
    for (int i=0; i<N; i++) {
        int id = ar.getResourceId(i, 0);
        if (id != 0) {
            Drawable dr = mResources.getDrawable(id);
        }
    }
    return N;
}

这里依次获取预加载的资源id，然后调用mResources.getDrawable(id)加载资源，资源加载后就会保存在Resources的缓存中。如下：

public Drawable getDrawable(int id) throws NotFoundException {
    synchronized (mTmpValue) {
        TypedValue value = mTmpValue;
        getValue(id, value, true);
        return loadDrawable(value, id);
    }
}

这个函数的解析我在这篇文章中讲过：如何进行资源的热修复

在loadDrawable中，首先看mDrawableCache中有没有，有的话直接返回，没有的话再去看sPreloadedDrawables缓存中有没有，如果有就返回，没有的话再去加载资源。值得注意的是加载资源时要区分是否是预加载的，预加载的资源是通过强引用放在sPreloadedDrawables中的，用户自定义的资源是通过弱引用放在mDrawableCache中的。如下：

Drawable loadDrawable(TypedValue value, int id)
            throws NotFoundException {
    final long key = (((long) value.assetCookie) << 32) | value.data;
    Drawable dr = getCachedDrawable(key);

    if (dr != null) {
        return dr;
    }

    Drawable.ConstantState cs = sPreloadedDrawables.get(key);
    if (cs != null) {
        dr = cs.newDrawable(this);
    } else {
        if (value.type >= TypedValue.TYPE_FIRST_COLOR_INT &&
                value.type <= TypedValue.TYPE_LAST_COLOR_INT) {
            dr = new ColorDrawable(value.data);
        }

        if (dr == null) {
            String file = value.string.toString();

            if (file.endsWith(".xml")) {
                XmlResourceParser rp = loadXmlResourceParser(
                            file, id, value.assetCookie, "drawable");
                dr = Drawable.createFromXml(this, rp);
                rp.close();
            } else {
                InputStream is = mAssets.openNonAsset(
                        value.assetCookie, file, AssetManager.ACCESS_STREAMING);
                dr = Drawable.createFromResourceStream(this, value, is,
                        file, null);
                is.close();
            }
        }
    }

    if (dr != null) {
        dr.setChangingConfigurations(value.changingConfigurations);
        cs = dr.getConstantState();
        if (cs != null) {
            if (mPreloading) {
                sPreloadedDrawables.put(key, cs);
            } else {
                synchronized (mTmpValue) {
                    mDrawableCache.put(key, new WeakReference<Drawable.ConstantState>(cs));
                }
            }
        }
    }

    return dr;
}

private static final LongSparseArray<Drawable.ConstantState> sPreloadedDrawables
        = new LongSparseArray<Drawable.ConstantState>();

private final LongSparseArray<WeakReference<Drawable.ConstantState> > mDrawableCache
        = new LongSparseArray<WeakReference<Drawable.ConstantState> >();

这里缓存中保存的都是Drawable.ConstantState，不是Drawable，真正获取Drawable是通过ConstantState的newDrawable来完成的。

这里会升起一个疑问，预加载的会不会只是一个外壳，而并没有分配内存，真正需要资源的时候才去分配内存么？我们来看看Drawable.ConstantState的实现，对于每一类Drawable都会有一个继承自ConstantState的内部类，我们以BitmapDrawable为例：

final static class BitmapState extends ConstantState {
    Bitmap mBitmap;
    int mChangingConfigurations;
    int mGravity = Gravity.FILL;
    Paint mPaint = new Paint(DEFAULT_PAINT_FLAGS);
    Shader.TileMode mTileModeX = null;
    Shader.TileMode mTileModeY = null;
    int mTargetDensity = DisplayMetrics.DENSITY_DEFAULT;
    boolean mRebuildShader;
    boolean mAutoMirrored;

    BitmapState(Bitmap bitmap) {
        mBitmap = bitmap;
    }

    BitmapState(BitmapState bitmapState) {
        this(bitmapState.mBitmap);
        mChangingConfigurations = bitmapState.mChangingConfigurations;
        mGravity = bitmapState.mGravity;
        mTileModeX = bitmapState.mTileModeX;
        mTileModeY = bitmapState.mTileModeY;
        mTargetDensity = bitmapState.mTargetDensity;
        mPaint = new Paint(bitmapState.mPaint);
        mRebuildShader = bitmapState.mRebuildShader;
        mAutoMirrored = bitmapState.mAutoMirrored;
    }

    @Override
    public Bitmap getBitmap() {
        return mBitmap;
    }

    @Override
    public Drawable newDrawable() {
        return new BitmapDrawable(this, null);
    }

    @Override
    public Drawable newDrawable(Resources res) {
        return new BitmapDrawable(this, res);
    }

    @Override
    public int getChangingConfigurations() {
        return mChangingConfigurations;
    }
}

这里newDrawable是调用的BitmapDrawable的构造函数，如下：

private BitmapDrawable(BitmapState state, Resources res) {
    mBitmapState = state;
    if (res != null) {
        mTargetDensity = res.getDisplayMetrics().densityDpi;
    } else {
        mTargetDensity = state.mTargetDensity;
    }
    setBitmap(state != null ? state.mBitmap : null);
}

这里首先将这个BitmapState设置到BitmapDrawable中，然后调用BitmapDrawable的setBitmap，如下：

private void setBitmap(Bitmap bitmap) {
    if (bitmap != mBitmap) {
        mBitmap = bitmap;
        if (bitmap != null) {
            computeBitmapSize();
        } else {
            mBitmapWidth = mBitmapHeight = -1;
        }
        invalidateSelf();
    }
}

可见，ConstantState的newDrawable并没有分配内存去new Drawable，只是套了一层Drawable的壳，那么分配内存是在哪里做的呢？
上面loadDrawable时，如果缓存中没有，就会去资源文件中加载资源，想必是在这里面做的。这里分两种情况，当资源文件是xml时，会调用
Drawable.createFromXml，否则会调用Drawable.createFromResourceStream。我们就只分析createFromResourceStream吧，原理应该大同小异。

public static Drawable createFromResourceStream(Resources res, TypedValue value,
            InputStream is, String srcName, BitmapFactory.Options opts) {
    Rect pad = new Rect();

    if (opts == null) opts = new BitmapFactory.Options();

    Bitmap  bm = BitmapFactory.decodeResourceStream(res, value, is, pad, opts);
    if (bm != null) {
        byte[] np = bm.getNinePatchChunk();
        if (np == null || !NinePatch.isNinePatchChunk(np)) {
            np = null;
            pad = null;
        }
        int[] layoutBounds = bm.getLayoutBounds();
        Rect layoutBoundsRect = null;
        if (layoutBounds != null) {
            layoutBoundsRect = new Rect(layoutBounds[0], layoutBounds[1],
                                         layoutBounds[2], layoutBounds[3]);
        }
        return drawableFromBitmap(res, bm, np, pad, layoutBoundsRect, srcName);
    }
    return null;
}

眼前一亮，这里出现了传说中的

Bitmap  bm = BitmapFactory.decodeResourceStream(res, value, is, pad, opts);

所以结论出来了，系统预加载资源时，会给这些Bitmap都decode到内存里，而且是强引用的，所以是GC不掉的。要清理这些内存就必须通过反射清理sPreloadedDrawable，不过要注意适配不同的sdk版本。