Dalvik GC

COW策略

一开始的时候（未复制Zygote进程的地址空间的时候），应用程序进程和Zygote进程共享了同一个用来分配对象的堆。当Zygote进程或者应用程序进程对该堆进行写操作时，内核就会执行真正的拷贝操作，使得Zygote进程和应用程序进程分别拥有自己的一份拷贝，这就是所谓的COW。因为copy是十分耗时的，所以必须尽量避免copy或者尽量少的copy。

和GC有关的一些指标

在启动Dalvik虚拟机的时候，我们可以分别通过-Xms、-Xmx和-XX:HeapGrowthLimit三个选项来指定上述三个值，以上三个值分别表示表示:

Starting Size： Dalvik虚拟机启动的时候，会先分配一块初始的堆内存给虚拟机使用。
Growth Limit：是系统给每一个程序的最大堆上限,超过这个上限，程序就会OOM
Maximum Size：不受控情况下的最大堆内存大小，起始就是我们在用largeheap属性的时候，可以从系统获取的最大堆大小

同时除了上面的这个三个指标外，还有几个指标也是值得我们关注的，那就是堆最小空闲值（Min Free）、堆最大空闲值（Max Free）和堆目标利用率（Target Utilization）。假设在某一次GC之后，存活对象占用内存的大小为LiveSize，那么这时候堆的理想大小应该为(LiveSize / U)。但是(LiveSize / U)必须大于等于(LiveSize + MinFree)并且小于等于(LiveSize + MaxFree)，每次GC后垃圾回收器都会尽量让堆的利用率往目标利用率靠拢。所以当我们尝试手动去生成一些几百K的对象，试图去扩大可用堆大小的时候，反而会导致频繁的GC，因为这些对象的分配会导致GC，而GC后会让堆内存回到合适的比例，而我们使用的局部变量很快会被回收理论上存活对象还是那么多，我们的堆大小也会缩减回来无法达到扩充的目的。与此同时这也是产生CONCURRENT GC的一个因素。

GC的类型

GC_FOR_MALLOC: 表示是在堆上分配对象时内存不足触发的GC。
GC_CONCURRENT: 当我们应用程序的堆内存达到一定量，或者可以理解为快要满的时候，系统会自动触发GC操作来释放内存。
GC_EXPLICIT: 表示是应用程序调用System.gc、VMRuntime.gc接口或者收到SIGUSR1信号时触发的GC。
GC_BEFORE_OOM: 表示是在准备抛OOM异常之前进行的最后努力而触发的GC。

GC类型	isPartial	isConcurrent	doPreserve
GC_FOR_MALLOC	Active	非并行	不回收软引
GC_CONCURRENT	Active	并行	不回收软引
GC_EXPLICIT	Active&Zygote	并行	不回收软引
GC_BEFORE_OOM	Active&Zygote	非并行	回收软引

对象的分配和GC触发时机

在对象的分配中会导致GC，第一次分配对象失败我们会触发GC但是不回收Soft的引用，如果再次分配还是失败我们就会将Soft的内存也给回收，前者触发的GC是GC_FOR_MALLOC类型的GC，后者是GC_BEFORE_OOM类型的GC。而当内存分配成功后，我们会判断当前的内存占用是否是达到了GC_CONCURRENT的阀值，如果达到了那么又会触发GC_CONCURRENT。

Java堆创建过程分析

Alloc.cpp: dvmGcStartup

bool dvmGcStartup()
{
    dvmInitMutex(&gDvm.gcHeapLock);
    pthread_cond_init(&gDvm.gcHeapCond, NULL);
    return dvmHeapStartup();
}

Heap.cpp: dvmHeapStartup

bool dvmHeapStartup()
{
    GcHeap *gcHeap;
    gcHeap = dvmHeapSourceStartup(gDvm.heapStartingSize,
                                  gDvm.heapMaximumSize,
                                  gDvm.heapGrowthLimit);
    if (gcHeap == NULL) {
        return false;
    }
    gDvm.gcHeap = gcHeap;
    if (!dvmCardTableStartup(gDvm.heapMaximumSize, gDvm.heapGrowthLimit)) {
        return false;
    }
    return true;
}

创建对象分配内存的过程

Alloc.cpp: dvmAllocObject

Object* dvmAllocObject(ClassObject* clazz, int flags)
{
    Object* newObj;
    newObj = (Object*)dvmMalloc(clazz->objectSize, flags);
    if (newObj != NULL) {
        DVM_OBJECT_INIT(newObj, clazz);
        dvmTrackAllocation(clazz, clazz->objectSize);   // notify DDMS 
    }
    return newObj;
}

Heap.cpp: dvmMalloc

void* dvmMalloc(size_t size, int flags)
{
    dvmLockHeap();
    ptr = tryMalloc(size);
    dvmUnlockHeap();
    if (ptr == NULL)  throwOOME();
    return ptr;
}

Heap.cpp: tryMalloc

static void *tryMalloc(size_t size)
{
    ptr = dvmHeapSourceAlloc(size);
    if (ptr != NULL)   return ptr;
    if (gDvm.gcHeap->gcRunning) {
        dvmWaitForConcurrentGcToComplete();
    } else {
      gcForMalloc(false);
    }
    ptr = dvmHeapSourceAlloc(size);
    if (ptr != NULL)  return ptr;
    ptr = dvmHeapSourceAllocAndGrow(size);
    if (ptr != NULL)  return ptr;
    gcForMalloc(true);
    ptr = dvmHeapSourceAllocAndGrow(size);
    if (ptr != NULL)  return ptr;
    LOGE_HEAP("Out of memory on a %zd-byte allocation.", size);
    dvmDumpThread(dvmThreadSelf(), false); 
    return NULL;
}

GC过程

GC_BEFORE_OOM 、GC_FOR_MALLOC

// Heap.cpp: gcForMalloc
static void gcForMalloc(bool clearSoftReferences)
{
    const GcSpec *spec = clearSoftReferences ? GC_BEFORE_OOM : GC_FOR_MALLOC;
    dvmCollectGarbageInternal(spec);
}

// Heap.cpp: dvmCollectGarbageInternal
void dvmCollectGarbageInternal(const GcSpec* spec)
{
    gcHeap->gcRunning = true;
    dvmSuspendAllThreads(SUSPEND_FOR_GC);
    // 初始化Mark Stack，并且设定好GC范围
    if (!dvmHeapBeginMarkStep(spec->isPartial)) {
        dvmAbort();
    }
    dvmHeapMarkRootSet();
    if (spec->isConcurrent) {
        dvmResumeAllThreads(SUSPEND_FOR_GC);
    }
    dvmHeapScanMarkedObjects();
    if (spec->isConcurrent) {
        dvmSuspendAllThreads(SUSPEND_FOR_GC);
        dvmHeapReMarkRootSet();
        dvmHeapReScanMarkedObjects();
    }
    if (spec->isConcurrent) {
        dvmResumeAllThreads(SUSPEND_FOR_GC);
    }
   // 根据设置的堆目标利用率调整堆的大小
    dvmHeapSourceGrowForUtilization();
    gcHeap->gcRunning = false;
    if (!spec->isConcurrent) {
        dvmResumeAllThreads(SUSPEND_FOR_GC);
    }
}

GC_CONCURRENT

// HeapSource.cpp: dvmHeapSourceAlloc
void* dvmHeapSourceAlloc(size_t n)
{
    void* ptr = mspace_calloc(heap->msp, 1, n);
    if (ptr == NULL) {
        return NULL;
    }
    countAllocation(heap, ptr);
    if (gDvm.gcHeap->gcRunning || !hs->hasGcThread) {
        return ptr;
    }
    if (heap->bytesAllocated > heap->concurrentStartBytes) {
       // 超过阈值，触发GC --> gcDaemonThread
        dvmSignalCond(&gHs->gcThreadCond);
    }
    return ptr;
}

static void *gcDaemonThread(void* arg)
{
    while (gHs->gcThreadShutdown != true) {
        bool trim = false;
        if (gHs->gcThreadTrimNeeded) {
            int result = dvmRelativeCondWait(&gHs->gcThreadCond, &gHs->gcThreadMutex,
                    HEAP_TRIM_IDLE_TIME_MS, 0);
            if (result == ETIMEDOUT) {
                /* Timed out waiting for a GC request, schedule a heap trim. */
                trim = true;
            }
        } else {
            dvmWaitCond(&gHs->gcThreadCond, &gHs->gcThreadMutex);
        }
        if (!gDvm.gcHeap->gcRunning) {
            dvmChangeStatus(NULL, THREAD_RUNNING);
            if (trim) {
                trimHeaps();
                gHs->gcThreadTrimNeeded = false;
            } else {
                dvmCollectGarbageInternal(GC_CONCURRENT);
                gHs->gcThreadTrimNeeded = true;
            }
        }
    }
    return NULL;
}

GC线程平时没事的时候，就在条件变量gHs->gcThreadCond上进行等待HEAP_TRIM_IDLE_TIME_MS毫秒（5000毫秒）。如果在HEAP_TRIM_IDLE_TIME_MS毫秒内，都没有得到执行GC的通知，那么它就调用函数trimHeaps对Java堆进行裁剪，以便可以将堆上的一些没有使用到的内存交还给内核。

GC_EXPLICIT

// Alloc.app: dvmCollectGarbage
void dvmCollectGarbage()
{
    if (gDvm.disableExplicitGc) {
        return;
    }
    dvmLockHeap();
    dvmWaitForConcurrentGcToComplete();
    dvmCollectGarbageInternal(GC_EXPLICIT);
    dvmUnlockHeap();
}