Java Instance类代码示例

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
private void visitRootObj(LeakNode node) {
  RootObj rootObj = (RootObj) node.instance;
  Instance child = rootObj.getReferredInstance();

  Exclusion exclusion = rootSuperClassAlwaysIgnored(child);

  if (exclusion != null && exclusion.alwaysExclude) {
    return;
  }

  if (rootObj.getRootType() == RootType.JAVA_LOCAL) {
    Instance holder = HahaSpy.allocatingThread(rootObj);
    // We switch the parent node with the thread instance that holds
    // the local reference.
    LeakNode parent = new LeakNode(null, holder, null, null, null);
    if (node.exclusion != null) {
      exclusion = node.exclusion;
    }
    enqueue(exclusion, parent, child, "<Java Local>", LOCAL);
  } else {
    enqueue(exclusion, node, child, null, null);
  }
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
private Exclusion rootSuperClassAlwaysIgnored(Instance child) {
  if (child == null) {
    return null;
  }
  Exclusion matchingParams = null;
  ClassObj superClassObj = child.getClassObj();
  while (superClassObj != null) {
    Exclusion params = excludedRefs.rootClassNames.get(superClassObj.getClassName());
    if (params != null) {
      // true overrides null or false.
      if (matchingParams == null || !matchingParams.alwaysExclude) {
        matchingParams = params;
      }
    }
    superClassObj = superClassObj.getSuperClassObj();
  }
  return matchingParams;
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
/**
 * Bitmaps and bitmap byte arrays are sometimes held by native gc roots, so they aren't included
 * in the retained size because their root dominator is a native gc root.
 * To fix this, we check if the leaking instance is a dominator for each bitmap instance and then
 * add the bitmap size.
 *
 * From experience, we've found that bitmap created in code (Bitmap.createBitmap()) are correctly
 * accounted for, however bitmaps set in layouts are not.
 */
private int computeIgnoredBitmapRetainedSize(Snapshot snapshot, Instance leakingInstance) {
  int bitmapRetainedSize = 0;
  ClassObj bitmapClass = snapshot.findClass("android.graphics.Bitmap");

  for (Instance bitmapInstance : bitmapClass.getInstancesList()) {
    if (isIgnoredDominator(leakingInstance, bitmapInstance)) {
      ArrayInstance mBufferInstance = fieldValue(classInstanceValues(bitmapInstance), "mBuffer");
      // Native bitmaps have mBuffer set to null. We sadly can't account for them.
      if (mBufferInstance == null) {
        continue;
      }
      long bufferSize = mBufferInstance.getTotalRetainedSize();
      long bitmapSize = bitmapInstance.getTotalRetainedSize();
      // Sometimes the size of the buffer isn't accounted for in the bitmap retained size. Since
      // the buffer is large, it's easy to detect by checking for bitmap size < buffer size.
      if (bitmapSize < bufferSize) {
        bitmapSize += bufferSize;
      }
      bitmapRetainedSize += bitmapSize;
    }
  }
  return bitmapRetainedSize;
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
private boolean isIgnoredDominator(Instance dominator, Instance instance) {
  boolean foundNativeRoot = false;
  while (true) {
    Instance immediateDominator = instance.getImmediateDominator();
    if (immediateDominator instanceof RootObj
        && ((RootObj) immediateDominator).getRootType() == RootType.UNKNOWN) {
      // Ignore native roots
      instance = instance.getNextInstanceToGcRoot();
      foundNativeRoot = true;
    } else {
      instance = immediateDominator;
    }
    if (instance == null) {
      return false;
    }
    if (instance == dominator) {
      return foundNativeRoot;
    }
  }
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
private void visitRootObj(LeakNode node) {
  RootObj rootObj = (RootObj) node.instance;
  Instance child = rootObj.getReferredInstance();

  if (rootObj.getRootType() == RootType.JAVA_LOCAL) {
    Instance holder = HahaSpy.allocatingThread(rootObj);
    // We switch the parent node with the thread instance that holds
    // the local reference.
    Exclusion exclusion = null;
    if (node.exclusion != null) {
      exclusion = node.exclusion;
    }
    LeakNode parent = new LeakNode(null, holder, null, null, null);
    enqueue(exclusion, parent, child, "<Java Local>", LOCAL);
  } else {
    enqueue(null, node, child, null, null);
  }
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
/**
 * Bitmaps and bitmap byte arrays are sometimes held by native gc roots, so they aren't included
 * in the retained size because their root dominator is a native gc root.
 * To fix this, we check if the leaking instance is a dominator for each bitmap instance and then
 * add the bitmap size.
 *
 * From experience, we've found that bitmap created in code (Bitmap.createBitmap()) are correctly
 * accounted for, however bitmaps set in layouts are not.
 */
private long computeIgnoredBitmapRetainedSize(Snapshot snapshot, Instance leakingInstance) {
  long bitmapRetainedSize = 0;
  ClassObj bitmapClass = snapshot.findClass("android.graphics.Bitmap");

  for (Instance bitmapInstance : bitmapClass.getInstancesList()) {
    if (isIgnoredDominator(leakingInstance, bitmapInstance)) {
      ArrayInstance mBufferInstance = fieldValue(classInstanceValues(bitmapInstance), "mBuffer");
      // Native bitmaps have mBuffer set to null. We sadly can't account for them.
      if (mBufferInstance == null) {
        continue;
      }
      long bufferSize = mBufferInstance.getTotalRetainedSize();
      long bitmapSize = bitmapInstance.getTotalRetainedSize();
      // Sometimes the size of the buffer isn't accounted for in the bitmap retained size. Since
      // the buffer is large, it's easy to detect by checking for bitmap size < buffer size.
      if (bitmapSize < bufferSize) {
        bitmapSize += bufferSize;
      }
      bitmapRetainedSize += bitmapSize;
    }
  }
  return bitmapRetainedSize;
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
ShortestPathFinder(ExcludedRefs excludedRefs) {
  this.excludedRefs = excludedRefs;
  toVisitQueue = new LinkedList<LeakNode>();
  toVisitIfNoPathQueue = new LinkedList<LeakNode>();
  toVisitSet = new LinkedHashSet<Instance>();
  toVisitIfNoPathSet = new LinkedHashSet<Instance>();
  visitedSet = new LinkedHashSet<Instance>();
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
private void visitClassObj(LeakNode node) {
  ClassObj classObj = (ClassObj) node.instance;
  Map<String, Exclusion> ignoredStaticFields =
      excludedRefs.staticFieldNameByClassName.get(classObj.getClassName());
  for (Map.Entry<Field, Object> entry : classObj.getStaticFieldValues().entrySet()) {
    Field field = entry.getKey();
    if (field.getType() != Type.OBJECT) {
      continue;
    }
    String fieldName = field.getName();
    if (fieldName.equals("$staticOverhead")) {
      continue;
    }
    Instance child = (Instance) entry.getValue();
    boolean visit = true;
    if (ignoredStaticFields != null) {
      Exclusion params = ignoredStaticFields.get(fieldName);
      if (params != null) {
        visit = false;
        if (!params.alwaysExclude) {
          enqueue(params, node, child, fieldName, STATIC_FIELD);
        }
      }
    }
    if (visit) {
      enqueue(null, node, child, fieldName, STATIC_FIELD);
    }
  }
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
private void visitArrayInstance(LeakNode node) {
  ArrayInstance arrayInstance = (ArrayInstance) node.instance;
  Type arrayType = arrayInstance.getArrayType();
  if (arrayType == Type.OBJECT) {
    Object[] values = arrayInstance.getValues();
    for (int i = 0; i < values.length; i++) {
      Instance child = (Instance) values[i];
      enqueue(null, node, child, "[" + i + "]", ARRAY_ENTRY);
    }
  }
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
private void enqueue(Exclusion exclusion, LeakNode parent, Instance child, String referenceName,
    LeakTraceElement.Type referenceType) {
  if (child == null) {
    return;
  }
  if (isPrimitiveOrWrapperArray(child) || isPrimitiveWrapper(child)) {
    return;
  }
  // Whether we want to visit now or later, we should skip if this is already to visit.
  if (toVisitSet.contains(child)) {
    return;
  }
  boolean visitNow = exclusion == null;
  if (!visitNow && toVisitIfNoPathSet.contains(child)) {
    return;
  }
  if (canIgnoreStrings && isString(child)) {
    return;
  }
  if (visitedSet.contains(child)) {
    return;
  }
  LeakNode childNode = new LeakNode(exclusion, child, parent, referenceName, referenceType);
  if (visitNow) {
    toVisitSet.add(child);
    toVisitQueue.add(childNode);
  } else {
    toVisitIfNoPathSet.add(child);
    toVisitIfNoPathQueue.add(childNode);
  }
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
static String threadName(Instance holder) {
  List<ClassInstance.FieldValue> values = classInstanceValues(holder);
  Object nameField = fieldValue(values, "name");
  if (nameField == null) {
    // Sometimes we can't find the String at the expected memory address in the heap dump.
    // See https://github.com/square/leakcanary/issues/417 .
    return "Thread name not available";
  }
  return asString(nameField);
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
/**
 * Searches the heap dump for a {@link KeyedWeakReference} instance with the corresponding key,
 * and then computes the shortest strong reference path from that instance to the GC roots.
 */
public AnalysisResult checkForLeak(File heapDumpFile, String referenceKey) {
  long analysisStartNanoTime = System.nanoTime();

  if (!heapDumpFile.exists()) {
    Exception exception = new IllegalArgumentException("File does not exist: " + heapDumpFile);
    return failure(exception, since(analysisStartNanoTime));
  }

  try {
    HprofBuffer buffer = new MemoryMappedFileBuffer(heapDumpFile);
    HprofParser parser = new HprofParser(buffer);
    Snapshot snapshot = parser.parse();
    deduplicateGcRoots(snapshot);

    Instance leakingRef = findLeakingReference(referenceKey, snapshot);

    // False alarm, weak reference was cleared in between key check and heap dump.
    if (leakingRef == null) {
      return noLeak(since(analysisStartNanoTime));
    }

    return findLeakTrace(analysisStartNanoTime, snapshot, leakingRef);
  } catch (Throwable e) {
    return failure(e, since(analysisStartNanoTime));
  }
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
private Instance findLeakingReference(String key, Snapshot snapshot) {
  ClassObj refClass = snapshot.findClass(KeyedWeakReference.class.getName());
  List<String> keysFound = new ArrayList<String>();
  for (Instance instance : refClass.getInstancesList()) {
    List<ClassInstance.FieldValue> values = classInstanceValues(instance);
    String keyCandidate = asString(fieldValue(values, "key"));
    if (keyCandidate.equals(key)) {
      return fieldValue(values, "referent");
    }
    keysFound.add(keyCandidate);
  }
  throw new IllegalStateException(
      "Could not find weak reference with key " + key + " in " + keysFound);
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
LeakNode(Exclusion exclusion, Instance instance, LeakNode parent,
    String referenceName, LeakTraceElement.Type referenceType) {
  this.exclusion = exclusion;
  this.instance = instance;
  this.parent = parent;
  this.referenceName = referenceName;
  this.referenceType = referenceType;
}
 

import com.squareup.haha.perflib.Instance; //导入依赖的package包/类
public List<TrackedReference> findTrackedReferences(File heapDumpFile) {
  if (!heapDumpFile.exists()) {
    throw new IllegalArgumentException("File does not exist: " + heapDumpFile);
  }
  try {
    HprofBuffer buffer = new MemoryMappedFileBuffer(heapDumpFile);
    HprofParser parser = new HprofParser(buffer);
    Snapshot snapshot = parser.parse();
    deduplicateGcRoots(snapshot);

    ClassObj refClass = snapshot.findClass(KeyedWeakReference.class.getName());
    List<TrackedReference> references = new ArrayList<>();
    for (Instance weakRef : refClass.getInstancesList()) {
      List<ClassInstance.FieldValue> values = classInstanceValues(weakRef);
      String key = asString(fieldValue(values, "key"));
      String name =
          hasField(values, "name") ? asString(fieldValue(values, "name")) : "(No name field)";
      Instance instance = fieldValue(values, "referent");
      if (instance != null) {
        String className = getClassName(instance);
        List<String> fields = describeFields(instance);
        references.add(new TrackedReference(key, name, className, fields));
      }
    }
    return references;
  } catch (Throwable e) {
    throw new RuntimeException(e);
  }
}