可见一个APP内存的占用惊人的达到了1.9G，并且几乎全是native内存，这个其实就是Google在8.0做的最大的一个优化，我们知道Java虚拟机一般是有一个上限，但是由于Android同时能运行多个APP，这个上限一般不会太高，拿nexus6p而言，一般是如下配置

dalvik.vm.heapstartsize=8m

dalvik.vm.heapgrowthlimit=192m

dalvik.vm.heapsize=512m

dalvik.vm.heaptargetutilization=0.75

dalvik.vm.heapminfree=512k

dalvik.vm.heapmaxfree=8m

在直接native内存分配，并且不释放，模拟代码如下：

void increase(){

     int size=1024*1024*100;

    char *Ptr = NULL;

    Ptr = (char *)malloc(size * sizeof(char));

    for(int i=0;i<size ;i++) {

      *(Ptr+i)=i%30;

    }

    for(int i=0;i<1024*1024 ;i++) {

       if(i%100==0)

      LOGI(" malloc  - %d" ,*(Ptr+i));

    }

}

 static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,

                               jint offset, jint stride, jint width, jint height,

                               jint configHandle, jboolean isMutable) {

     SkColorType colorType = GraphicsJNI::legacyBitmapConfigToColorType(configHandle);

      ... 

     SkBitmap Bitmap;

     Bitmap.setInfo(SkImageInfo::Make(width, height, colorType, kPremul_SkAlphaType));

           <!--关键点1 像素内存分配-->

     Bitmap* nativeBitmap = GraphicsJNI::allocateJavaPixelRef(env, &Bitmap, NULL);

     if (!nativeBitmap) {

         return NULL;

     }

      ...

     <!--获取分配地址-->

     jbyte* addr = (jbyte*) env->CallLongMethod(gVMRuntime, gVMRuntime_addressOf, arrayObj);

     ...

     <!--创建Bitmap-->

     android::Bitmap* wrapper = new android::Bitmap(env, arrayObj, (void*) addr,

             info, rowBytes, ctable);

     wrapper->getSkBitmap(Bitmap);

     Bitmap->lockPixels();

     return wrapper;

 }

android::Bitmap* GraphicsJNI::allocateJavaPixelRef(JNIEnv* env, SkBitmap* bitmap,

                                             SkColorTable* ctable) {

    const SkImageInfo& info = bitmap->info();

    if (info.fColorType == kUnknown_SkColorType) {

        doThrowIAE(env, "unknown bitmap configuration");

        return NULL;

    }

    size_t size;

    if (!computeAllocationSize(*bitmap, &size)) {

        return NULL;

    }

    // we must respect the rowBytes value already set on the bitmap instead of

    // attempting to compute our own.

    const size_t rowBytes = bitmap->rowBytes();

   <!--关键点1 ，创建Java层字节数据，作为数据存储单元-->

    jbyteArray arrayObj = (jbyteArray) env->CallObjectMethod(gVMRuntime,

                                                             gVMRuntime_newNonMovableArray,

                                                             gByte_class, size);

    if (env->ExceptionCheck() != 0) {

        return NULL;

    }

    SkASSERT(arrayObj);

    jbyte* addr = (jbyte*) env->CallLongMethod(gVMRuntime, gVMRuntime_addressOf, arrayObj);

    if (env->ExceptionCheck() != 0) {

        return NULL;

    }

    SkASSERT(addr);

    android::Bitmap* wrapper = new android::Bitmap(env, arrayObj, (void*) addr,

            info, rowBytes, ctable);

    wrapper->getSkBitmap(bitmap);

    // since we're already allocated, we lockPixels right away

    // HeapAllocator behaves this way too

    bitmap->lockPixels();

    return wrapper;

}

jobject GraphicsJNI::createBitmap(JNIEnv* env, android::Bitmap* bitmap,

        int bitmapCreateFlags, jbyteArray ninePatchChunk, jobject ninePatchInsets,

        int density) {

       ...<!--关键点1，构建java Bitmap对象，并设置byte[] mBuffer-->

    jobject obj = env->NewObject(gBitmap_class, gBitmap_constructorMethodID,

            reinterpret_cast<jlong>(bitmap), bitmap->javaByteArray(),

            bitmap->width(), bitmap->height(), density, isMutable, isPremultiplied,

            ninePatchChunk, ninePatchInsets);

    hasException(env); // For the side effect of logging.

    return obj;

}

public final class Bitmap implements Parcelable {

    ...

    // Convenience for JNI access

    private final long mNativePtr;

    ...

 }

static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,

                              jint offset, jint stride, jint width, jint height,

                              jint configHandle, jboolean isMutable,

                              jfloatArray xyzD50, jobject transferParameters) {

    SkColorType colorType = GraphicsJNI::legacyBitmapConfigToColorType(configHandle);

        ...

        <!--关键点1 ，native层创建bitmap，并分配native内存-->

    sk_sp<Bitmap> nativeBitmap = Bitmap::allocateHeapBitmap(&Bitmap);

    if (!nativeBitmap) {

        return NULL;

    }

    ...

    return createBitmap(env, nativeBitmap.release(), getPremulBitmapCreateFlags(isMutable));

}

static sk_sp<Bitmap> allocateHeapBitmap(size_t size, const SkImageInfo& info, size_t rowBytes) {

       <!--关键点1 直接calloc分配内存-->

    void* addr = calloc(size, 1);

    if (!addr) {

        return nullptr;

    }

     <!--关键点2 创建native Bitmap-->

    return sk_sp<Bitmap>(new Bitmap(addr, size, info, rowBytes));

}

Bitmap(long nativeBitmap, int width, int height, int density,

        boolean isMutable, boolean requestPremultiplied,

        byte[] ninePatchChunk, NinePatch.InsetStruct ninePatchInsets) {

    ...

    mNativePtr = nativeBitmap;

    long nativeSize = NATIVE_ALLOCATION_SIZE + getAllocationByteCount();

    <!--辅助回收native内存-->

    NativeAllocationRegistry registry = new NativeAllocationRegistry(

        Bitmap.class.getClassLoader(), nativeGetNativeFinalizer(), nativeSize);

    registry.registerNativeAllocation(this, nativeBitmap);

   if (ResourcesImpl.TRACE_FOR_DETAILED_PRELOAD) {

        sPreloadTracingNumInstantiatedBitmaps++;

        sPreloadTracingTotalBitmapsSize += nativeSize;

    }

}

当然这个功能也要Java虚拟机的支持，有机会再分析。

          /**

         * @deprecated As of {@link android.os.Build.VERSION_CODES#LOLLIPOP}, this is

         * ignored.

         *

         * In {@link android.os.Build.VERSION_CODES#KITKAT} and below, if this

         * is set to true, then the resulting bitmap will allocate its

         * pixels such that they can be purged if the system needs to reclaim

         * memory. In that instance, when the pixels need to be accessed again

         * (e.g. the bitmap is drawn, getPixels() is called), they will be

         * automatically re-decoded.

         *

         * <p>For the re-decode to happen, the bitmap must have access to the

         * encoded data, either by sharing a reference to the input

         * or by making a copy of it. This distinction is controlled by

         * inInputShareable. If this is true, then the bitmap may keep a shallow

         * reference to the input. If this is false, then the bitmap will

         * explicitly make a copy of the input data, and keep that. Even if

         * sharing is allowed, the implementation may still decide to make a

         * deep copy of the input data.</p >

         *

         * <p>While inPurgeable can help avoid big Dalvik heap allocations (from

         * API level 11 onward), it sacrifices performance predictability since any

         * image that the view system tries to draw may incur a decode delay which

         * can lead to dropped frames. Therefore, most apps should avoid using

         * inPurgeable to allow for a fast and fluid UI. To minimize Dalvik heap

         * allocations use the {@link #inBitmap} flag instead.</p >

         *

         * <p class="note"><strong>Note:</strong> This flag is ignored when used

         * with {@link #decodeResource(Resources, int,

         * android.graphics.BitmapFactory.Options)} or {@link #decodeFile(String,

         * android.graphics.BitmapFactory.Options)}.</p >

         */

        @Deprecated

        public boolean inPurgeable;

        /**

         * @deprecated As of {@link android.os.Build.VERSION_CODES#LOLLIPOP}, this is

         * ignored.

         *

         * In {@link android.os.Build.VERSION_CODES#KITKAT} and below, this

         * field works in conjuction with inPurgeable. If inPurgeable is false,

         * then this field is ignored. If inPurgeable is true, then this field

         * determines whether the bitmap can share a reference to the input

         * data (inputstream, array, etc.) or if it must make a deep copy.

         */

        @Deprecated

        public boolean inInputShareable;