Android内存分配/回收的一个问题-为什么内存使用很少的时候也GC

static size_t getUtilizationTarget(const HeapSource* hs, size_t liveSize)
{
    size_t targetSize = (liveSize / hs->targetUtilization) * HEAP_UTILIZATION_MAX;
    if (targetSize > liveSize + hs->maxFree) {
        targetSize = liveSize + hs->maxFree;
    } else if (targetSize < liveSize + hs->minFree) {
        targetSize = liveSize + hs->minFree;
    }
    return targetSize;
}

   static void *tryMalloc(size_t size)
    {
        void *ptr;
        <!--1 首次请求分配内存-->
        ptr = dvmHeapSourceAlloc(size);
        if (ptr != NULL) {
            return ptr;
        }
        <!--2 分配失败，GC-->
        if (gDvm.gcHeap->gcRunning) {
            dvmWaitForConcurrentGcToComplete();
        } else {
                  //false 弱引用
          gcForMalloc(false);
        }
        <!--再次分配-->
        ptr = dvmHeapSourceAlloc(size);
        if (ptr != NULL) {
            return ptr;
        }
         <!--还是分配失败，调整softLimit再次分配-->
        ptr = dvmHeapSourceAllocAndGrow(size);
        if (ptr != NULL) {
            size_t newHeapSize;
       <!--分配成功后要调整softLimit-->
            newHeapSize = dvmHeapSourceGetIdealFootprint();
            return ptr;
        }
         <!--还是分配失败，GC力加强，回收soft引用，-->
                //true 软引用
        gcForMalloc(true);
        <!--再次请求分配，如果还是失败，那就OOM了-->
        ptr = dvmHeapSourceAllocAndGrow(size);
        if (ptr != NULL) {
            return ptr;
        }
        dvmDumpThread(dvmThreadSelf(), false);          return NULL;  
        }

    static void *tryMalloc(size_t size)
    {
        void *ptr;
    //TODO: figure out better heuristics
    //    There will be a lot of churn if someone allocates a bunch of
    //    big objects in a row, and we hit the frag case each time.
    //    A full GC for each.
    //    Maybe we grow the heap in bigger leaps
    //    Maybe we skip the GC if the size is large and we did one recently
    //      (number of allocations ago) (watch for thread effects)
    //    DeflateTest allocs a bunch of ~128k buffers w/in 0-5 allocs of each other
    //      (or, at least, there are only 0-5 objects swept each time)
          <!--1 首次请求分配内存-->
        ptr = dvmHeapSourceAlloc(size);
        if (ptr != NULL) {
            return ptr;
        }
        /*
         * The allocation failed.  If the GC is running, block until it
         * completes and retry.
         */
         <!--2 分配失败，GC--> 
        if (gDvm.gcHeap->gcRunning) {
            /*
             * The GC is concurrently tracing the heap.  Release the heap
             * lock, wait for the GC to complete, and retrying allocating.
             */
            dvmWaitForConcurrentGcToComplete();
        } else {
          /*
           * Try a foreground GC since a concurrent GC is not currently running.
           */
          //false 弱引用
          gcForMalloc(false);
        }
        ptr = dvmHeapSourceAlloc(size);
        if (ptr != NULL) {
            return ptr;
        }
        /* Even that didn't work;  this is an exceptional state.
         * Try harder, growing the heap if necessary.
         */
        ptr = dvmHeapSourceAllocAndGrow(size);
        if (ptr != NULL) {
            size_t newHeapSize;
             <!--分配成功后要调整softLimit-->
            newHeapSize = dvmHeapSourceGetIdealFootprint();
    //TODO: may want to grow a little bit more so that the amount of free
    //      space is equal to the old free space + the utilization slop for
    //      the new allocation.
            LOGI_HEAP("Grow heap (frag case) to "
                    "%zu.%03zuMB for %zu-byte allocation",
                    FRACTIONAL_MB(newHeapSize), size);
            return ptr;
        }
        /* Most allocations should have succeeded by now, so the heap
         * is really full, really fragmented, or the requested size is
         * really big.  Do another GC, collecting SoftReferences this
         * time.  The VM spec requires that all SoftReferences have
         * been collected and cleared before throwing an OOME.
         */
    //TODO: wait for the finalizers from the previous GC to finish
        LOGI_HEAP("Forcing collection of SoftReferences for %zu-byte allocation",
                size);
        <!--还是分配失败，GC力加强，回收soft引用，-->
         //true 软引用
        gcForMalloc(true);
        ptr = dvmHeapSourceAllocAndGrow(size);
        if (ptr != NULL) {
            return ptr;
        }
    //TODO: maybe wait for finalizers and try one last time
        LOGE_HEAP("Out of memory on a %zd-byte allocation.", size);
    //TODO: tell the HeapSource to dump its state
        dvmDumpThread(dvmThreadSelf(), false);
        return NULL;
    }