repository·main·Indexed 11 days ago
https://github.com/square/leakcanaryA memory leak detection library for Android that helps developers identify and resolve leaks during development. It monitors object lifecycles, triggers heap dumps when objects are retained, and performs on-device analysis using the Shark heap parser. LeakCanary automatically watches standard Android lifecycle components like Activities, Fragments, ViewModels, and Services, providing actionable leak traces from GC roots down to the retained object.
Shark is a high-speed, low-memory footprint heap analysis library written in Kotlin. It is the engine that powers LeakCanary 2 and is designed to run in both Java and Android VMs. Shark is modular and released in layers, allowing developers to use specific components depending on their needs:
Accumulated memory leaks cause increased memory usage, leading to more frequent Garbage Collection (GC) cycles. This consumes CPU and causes UI jank, freezes, and Application Not Responding (ANR) reports, eventually resulting in OutOfMemoryError (OOME) crashes.
LeakCanary helps developers identify and fix these leaks during development to prevent production crashes.
Note on OOME Reporting: Crash reporting tools may not accurately aggregate OutOfMemoryError crashes. Because an OOME can be thrown from any part of the app code when memory is low, each instance may have a unique stacktrace. This causes OOMEs to appear as many distinct, low-occurrence crashes rather than a single high-frequency crash entry.
In a Java-based runtime, a memory leak is a programming error where an application maintains a reference to an object that is no longer needed. Because a reference still exists, the memory allocated for that object cannot be reclaimed by the Garbage Collector (GC).
Example: An Android Activity instance is no longer needed after its onDestroy() method is called. If a reference to that instance is stored in a static field, the Activity cannot be garbage collected, resulting in a leak.
The chain pane displays the shortest path from a GC root to the selected object. It is organized as follows:
LazyColumn to display rows, where each row represents one object in the chain. This allows the UI to handle chains with hundreds or thousands of steps efficiently.PathDetail.BRIEF: A condensed view used for the pointer's hover card. It drops the package, address, and instance type, keeping only the retained size inline with the class name to save space.PathDetail.FULL: The complete view shown in the details pane for a clicked object, preserving all technical details of each step.LeakCanary uses heuristics to determine if an object is alive or dead (e.g., knowing that an Application is a singleton and never leaks). You can extend this behavior by providing your own knowledge about your custom types' lifecycles.
By teaching LeakCanary about your specific types, you allow it to automatically narrow the 'window of unknowns' in leak traces involving your code. This is implemented via an inspector that reads an object and reports conclusions that LeakCanary then uses to automate future analyses.
Shark Explorer joins retrieved images (from JDWP or am dumpheap -b png) to the heap dump using the bitmap's native pointer as the join key.
Because native pointers represent addresses in memory, they can be reused once a bitmap is recycled. To prevent showing the wrong image (pixels from a new bitmap being shown for an old one), the explorer implements a safety check: an image is only accepted if its dimensions match the bitmap it is being joined to. The PNG's IHDR header is used to verify the size. Mismatches are tracked in BitmapCounts.mismatchedCount.
The ViewChildReferenceReader provides a ViewGroup with one virtual reference per child, named by index. This allows the OwnerRule to claim ownership of child views through the parent.
mChildren bounded by mChildrenCount. These references are marked as virtual, meaning they are additive to the existing heap structure but do not replace the actual underlying array.View[] array. This prevents large View[] arrays from appearing as the primary retainers of a window's memory.mChildren, ensuring every object remains a node exactly once.View[] element itself no longer 'owns' the child; it is treated as a rival. This ensures that if a view is in a slot that the parent no longer counts (e.g., during an addViewInner operation), it falls back to the array holding it rather than being incorrectly attributed to a parent that doesn't hold it.Shark Explorer uses a cooperative cancellation model to ensure that unwanted UI requests (like a user dragging a window or moving a pointer quickly) do not clog the heap dump thread.
HeapDumpSession uses a CancelSignal. This signal is checked during every record read and during long analysis stretches.LaunchedEffect in Compose).by lazy, and internal walks reuse arrays by using generation stamping, ensuring that a cancelled walk leaves no corrupted state.LeakCanary does not monitor aggregate memory measurements or OutOfMemoryError symptoms. Instead, it monitors individual objects.
When an object's lifecycle ends (e.g., an Activity is destroyed), the app signals that the object should be deleted. LeakCanary watches these specific objects. If the object remains reachable via a chain of references after its lifecycle has ended, it is considered retained, and LeakCanary triggers a heap dump analysis to find the cause.
When writing UI tests for Shark Explorer, be aware of how Compose semantics work:
Modifier.clickable merges its descendants. For example, onNodeWithText("com.example.Holder") will find the entire chain of an identity block if any of its lines match the text. However, the same text appearing in a separate bar above the map is considered a distinct node.waitForTheTree (which waits for the view to stop spinning) or wait for a specific log line that a layout writes to confirm the map has moved.LeakCanary does not dump the heap immediately upon finding a single leak. Instead, it waits until a threshold of retained objects is met to avoid excessive performance impact.
Default Thresholds:
If you see a notification about retained objects and then move the app to the background, LeakCanary will dump the heap within 5 seconds. You can also tap the notification to force an immediate heap dump.