Identifying memory leaks in Android applications

Nov 7, 201228 likes33,711 views

A very brief introduction to using DDMS and Eclipse Memory Analyzer to identify the source of a memory leak in an Android application.

Identifying memory leaks in
Android applications
Zachary Blair

Doesn’t Java handle memory management?!!!1

http://memegenerator.net/instance/27508171

Garbage collection !=
Immunity from memory leaks!

Java/Android Garbage Collection
• All objects created with new are stored on the heap

• GC periodically disposes of objects that are eligible for
garbage collection

• Android GC uses a mark-and-sweep algorithm

What is “eligible for garbage collection”?
• Not reachable from any live threads or any static
references
− There are no references to the object!

• Cyclic references are not counted.

What is “eligible for garbage collection”?

Simple Example:

Integer volume = new Integer(100);
Integer
System.out.println(volume); 100

volume = null;
Volume

What is “eligible for garbage collection”?

Simple Example:

Integer volume = new Integer(100);
Integer
System.out.println(volume); 100

volume = null; null

Volume

What is “eligible for garbage collection”?

Simple Example:

Integer volume = new Integer(100); Integer
Garbage
System.out.println(volume); collected!

volume = null; null

Volume

What is “eligible for garbage collection”?
• Lists, Maps, and Sets are prime suspects for memory
leaks, because they can accidentally retain references to
unused objects!

Integer volume = new Integer(100);
Integer
System.out.println(volume); 100

volumeList.add(volume); null

volume = null; Volume volumeList

Haiku Break #1

Memory leak, crash.
Lingering reference, why!?
You make GC cry.

Detecting a memory leak
Clue #1: Your application crashes with an
java.lang.OutOfMemoryError after running for a long time.
Clue #2: You see frequent GC_ lines in logcat before the
crash.

D/dalvikvm( 1325): GC_CONCURRENT freed 1971K,
18% free 12382K/14983K, paused 3ms+7ms

Heap statistics
Reason for garbage
collection:
GC_CONCURRENT
GC_FOR_MALLOC
GC_EXTERNAL_ALLOC
GC_HPROF_DUMP_HEAP
GC_EXPLICIT

Identifying the source of the leak
• Step #1
Use DDMS (Dalvik Debug Monitor Server) to dump heap
snapshots (an HPROF file)
− android-sdkstoolsddms.bat

Identifying the source of the leak
• Step #2
Use the Android SDK’s “hprof-conv” tool to convert the
Android-specific HPROF file into a generic HPROF file
that can be analyzed by Eclipse Memory Analyzer

Identifying the source of the leak
• Step #3
Open the converted HPROF using Eclipse Memory
Analyzer

Identifying the source of the leak
• Step #4
Analyze the results using the “Histogram” view

Identifying the source of the leak
• Step #4
Analyze the results using the “Histogram” view

• Identifies types of objects allocated!
• Doesn’t know whether they will eventually be freed!
• We must compare two HPROF snapshots to identify
which objects are responsible for a leak.

Identifying the source of the leak
• Step #5
Exercise your app in a way that tends to cause it to
exhibit the memory leak, and then use DDMS to dump
another heap snapshot

• Step #6
Use “hprof-conv” to convert the HPROF file

Identifying the source of the leak
• Step #7
Open both HPROF files in Eclipse Memory Analyzer and
compare their histograms

Identifying the source of the leak
• Step #7
Open both HPROF files in Eclipse Memory Analyzer and
compare their histograms
− Compare the number of instances and sizes of each type of object
between the two snapshots.
− A sustained increase in the number of objects may indicate a leak!

Identifying the source of the leak
• Step #7

Shallow heap: the size of the objects themselves.
Retained heap: the amount that would be freed if we freed
these objects (greater than shallow heap because
referenced objects may also be freed).

Haiku Break #2

Unfreed memory,
Delta of two HPROF dumps
Who references thou?

Fixing the leak
• The leak must be the result of unused objects still having
references to them so, you can do one of:
− Stop creating the objects
− Stop maintaining references to the objects
− Use weak references (see WeakHashMap) so that those
references are invalidated if they are the only ones to the object.
− Make sure to close() open streams and connections

More Information
• Google I/O 2011: Memory management for Android
Apps https://www.youtube.com/watch?v=_
CruQY55HOk&feature=relmfu

The document discusses Java garbage collection. It explains that Java's garbage collector automatically manages memory by freeing unreferenced objects. The garbage collector runs when memory is low to find and delete objects that cannot be reached. While garbage collection provides convenience, it has overhead as the system must pause current execution to run it which can influence user experience. The document also describes how objects are identified as garbage using tracing and reference counting collectors as well as how to explicitly make objects available for collection and finalize objects before deletion.

Garbage collection in JVMaragozin

Java GCRay Cheng

The document discusses Java garbage collection. It begins with an introduction to garbage collection, explaining that it is used to release unused memory and each JVM can implement its own garbage collection algorithms. It then covers the main garbage collection algorithms of reference counting, mark and sweep, and stop and copy. It also discusses finalize() methods, reference types in Java including strong, soft, weak and phantom references, and tips for improving garbage collection performance in Java programs.

Garbage collection 介紹kao kuo-tung

This document discusses garbage collection techniques in Python. It begins by introducing the speaker's past presentations on Python debugging and code execution. It then covers reference counting, mark and sweep collection, and generational collection used in Python. It discusses advantages and disadvantages of different techniques. It also introduces the gc module interface in Python for controlling and debugging garbage collection.

GC in C#Kamal1997

The document discusses garbage collection in .NET. It covers: - The .NET framework automatically manages memory through garbage collection. Objects are allocated on the managed heap or stack. - There are three generations for objects - generation 0 for short-lived objects, generation 1 as a buffer, and generation 2 for long-lived objects. Surviving objects are promoted between generations. - Garbage collection can be concurrent, background, or non-concurrent. Server garbage collection uses multiple threads for faster collection while workstation GC competes with other threads.

JDD 2016 - Grzegorz Rozniecki - Java 8 What Could Possibly Go WrongPROIDEA

It’s late 2016, so you probably have been using Java 8 goodies for a while: lambdas, Stream, Optional, new date API ‒ stuff which makes Java development much more pleasant. But the question is: do you know these tools well? I bet you said yes, because writing sweet Java 8 code is piece of cake ‒ you’re using efficient, parallel streams and many lambdas, so what could possibly go wrong? Let me put this straight: most probably you’re doing something wrong. In this talk I won’t actually try to prove that you don’t know what you’re doing, on the contrary ‒ I’ll try to help you be a better programmer by pointing out few mistakes you can make when writing Java 8 code (I know that because I made them all). I’ll also discuss couple common misconceptions regarding Stream and Optional and mention missing language features (also if there is a chance to see them in Java 9 or what library should you use instead). Last but not least, I’ll present you a number of lesser-known gems I found in deepest corners of JDK API, which, I hope, will make your life as a software developer a little bit easier.

DotNetFest - Let’s refresh our memory! Memory management in .NETMaarten Balliauw

The .NET Garbage Collector (GC) is really cool. It helps providing our applications with virtually unlimited memory, so we can focus on writing code instead of manually freeing up memory. But how does .NET manage that memory? What are hidden allocations? Are strings evil? It still matters to understand when and where memory is allocated. In this talk, we’ll go over the base concepts of .NET memory management and explore how .NET helps us and how we can help .NET – making our apps better. Expect profiling, Intermediate Language (IL), ClrMD and more!

Java Garbage Collection - How it worksMindfire Solutions

Understanding Java Garbage Collection - And What You Can Do About ItAzul Systems Inc.

Garbage collection is an integral but often misunderstood part of application behavior on Java platforms. As such, it is important for Java developers to understand how collector mechanisms work. This presentation reviews and classifies the major garbage collectors available in JVMs today. Following an overview of common garbage collection techniques such as generational, parallel, stop-the-world, incremental, and concurrent algorithms, it defines terms and metrics common to all collectors. It also discusses trade-offs in balancing requirements for responsiveness, throughput, space, and available memory and covers some pitfalls, common misconceptions, and garbage collection behavior myths.

Detecting Memory Leaks in Android AppDinesh Prajapati

.NET Fest 2018. Maarten Balliauw. Let’s refresh our memory! Memory management...NETFest

RxJS - The Reactive Extensions for JavaScriptViliam Elischer

RxJS is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. It offers a language neutral approach to reactive programming using observables that asynchronously push values to observers. Some key benefits of RxJS include clean asynchronous code, error handling, composable observables, and abstraction. The core concepts include observables, observers, and operators to process and transform streams of data over time.

JetBrains Australia 2019 - Exploring .NET’s memory management – a trip down m...Maarten Balliauw

This document discusses .NET memory management and the garbage collector. It explains that the CLR manages memory in a heap and the garbage collector reclaims unused memory. It describes how objects are allocated in generations and discusses how to help the garbage collector perform better by reducing allocations, using value types when possible, and properly disposing of objects. The document also provides examples of hidden allocations and demonstrates tools for analyzing memory usage like ClrMD and dotMemory Unit.

My Gentle Introduction to RxJSMattia Occhiuto

This document introduces reactive programming and RxJS. It defines reactive systems as being responsive, resilient, elastic, and message-driven. Reactive programming uses asynchronous data streams and is more declarative, reusable, and testable. RxJS uses Observables to represent push-based collections of multiple values over time. Observables can be subscribed to and provide notifications for next events, errors, and completion. More than 120 operators allow manipulating Observable streams similarly to arrays. The document advocates for using RxJS to represent asynchronous data from various sources to build modern web applications in a reactive way.

Hadoop cluster performance profilerIhor Bobak

Reactive Android: RxJava and beyondFabio Tiriticco

Building Sexy Real-Time Analytics Systems - Erlang Factory NYC / Toronto 2013lpgauth

The document discusses the evolution of architectures for building real-time analytics systems. It describes moving from a single node architecture using Node.js and Socket.io to a distributed architecture using Erlang processes and libraries like GProc (pub/sub) and Bullet (Cowboy). The latest architecture introduced is called Swirl, which is a lightweight distributed stream processing system that uses Erlang terms and processes to filter, aggregate, and reduce streams of events in real-time across multiple nodes.

Functional Reactive Programming / Compositional Event SystemsLeonardo Borges

This document provides an overview of functional reactive programming (FRP) and compositional event systems (CES). It discusses how FRP approaches handling time-varying values like regular values. It presents an example of modeling game movements reactively using key press events. It also demonstrates how CES can be used to handle asynchronous workflows by turning network responses into observable streams. The document compares CES to other approaches like core.async and discusses benefits of CES like supporting multiple subscribers.

Performance Monitoring for Docker Environments - Docker Amsterdam June MeetupStijn Polfliet

Performance monitoring for Docker Challenges around Docker monitoring - Anomaly detection - CoScale demo For more info about how to use CoScale Docker monitoring, some reading material here: http://www.coscale.com/blog/how-to-monitor-docker-containers-with-coscale and http://www.coscale.com/blog/how-to-monitor-your-kubernetes-cluster A summary of CoScale Docker performance monitoring can be found here: http://www.coscale.com/docker-monitoring

Quantifying the Performance of Garbage Collection vs. Explicit Memory ManagementEmery Berger

This talk answers an age-old question: is garbage collection faster/slower/the same speed as malloc/free? We introduce oracular memory management, an approach that lets us measure unaltered Java programs as if they used malloc and free. The result: a good GC can match the performance of a good allocator, but it takes 5X more space. If physical memory is tight, however, conventional garbage collectors suffer an order-of-magnitude performance penalty.

Real world functional reactive programmingEric Polerecky

FRP is about programming with asynchronous data streams declaratively. Reactive programming treats everything as an asynchronous data stream. FRP uses concepts from functional programming like immutable data and first class functions. The key abstraction in FRP is IObservable which represents a stream of events or values over time. FRP is useful for handling events, stateful applications, and incoming data streams from sources like the file system, sensors, or HTTP requests.

An Introduction to RxJavaSanjay Acharya

Introduction to c part -3baabtra.com - No. 1 supplier of quality freshers

The document provides an introduction to memory management in C. It discusses that memory can be allocated in C either by declaring variables, which allocates space on the stack, or by explicitly requesting space from C using functions like malloc(), which allocates space on the heap. The stack follows LIFO order and releases space automatically when the program finishes, while the heap requires manual memory management using free(). Functions like malloc() allocate raw memory on the heap and return a pointer to it, while calloc() allocates initialized memory in blocks. The document also discusses stack overflow and the different memory sections in RAM like text, data, BSS, and heap.

RxJS and Reactive Programming - Modern Web UI - May 2015Ben Lesh

Debugging Complex Systems - Erlang Factory SF 2015lpgauth

The Popper Experimentation Protocol and CLI toolIvo Jimenez

あなたのScalaを爆速にする７つの方法x1 ichi

Android - Preventing common memory leaksAli Muzaffar

The document discusses common causes of and solutions to memory leaks in Android applications. It covers issues related to using the correct Context, holding references to activities from outside their scope, non-static inner classes holding implicit references to their outer class, threads not being garbage collected, and forgetting to recycle bitmaps. The key recommendations are to always use Application Context when possible, avoid leaking references between scopes, make handlers and inner classes static when possible, implement cancellation for threads, and properly recycle bitmaps.

Memory leakAnandraj Kulkarni

This document discusses memory leaks in Java. It provides an overview of the Java heap and generations. A memory leak occurs when objects are not removed from the heap even when no longer needed. Symptoms include frequent full garbage collections and a decreasing free heap over time. Tools like GCViewer and JProfiler can analyze garbage collection logs and heap usage to troubleshoot leaks. Best practices to avoid leaks include monitoring heap usage, freeing unnecessary objects, closing connections, and limiting session data.

More Related Content

What's hot (20)

Java Garbage Collection - How it worksMindfire Solutions

Understanding Java Garbage Collection - And What You Can Do About ItAzul Systems Inc.

Detecting Memory Leaks in Android AppDinesh Prajapati

.NET Fest 2018. Maarten Balliauw. Let’s refresh our memory! Memory management...NETFest

RxJS - The Reactive Extensions for JavaScriptViliam Elischer

JetBrains Australia 2019 - Exploring .NET’s memory management – a trip down m...Maarten Balliauw

My Gentle Introduction to RxJSMattia Occhiuto

Hadoop cluster performance profilerIhor Bobak

Reactive Android: RxJava and beyondFabio Tiriticco

Building Sexy Real-Time Analytics Systems - Erlang Factory NYC / Toronto 2013lpgauth

Functional Reactive Programming / Compositional Event SystemsLeonardo Borges

Performance Monitoring for Docker Environments - Docker Amsterdam June MeetupStijn Polfliet

Quantifying the Performance of Garbage Collection vs. Explicit Memory ManagementEmery Berger

Real world functional reactive programmingEric Polerecky

An Introduction to RxJavaSanjay Acharya

Introduction to c part -3baabtra.com - No. 1 supplier of quality freshers

RxJS and Reactive Programming - Modern Web UI - May 2015Ben Lesh

Debugging Complex Systems - Erlang Factory SF 2015lpgauth

The Popper Experimentation Protocol and CLI toolIvo Jimenez

あなたのScalaを爆速にする７つの方法x1 ichi

Java Garbage Collection - How it worksMindfire Solutions

Understanding Java Garbage Collection - And What You Can Do About ItAzul Systems Inc.

Detecting Memory Leaks in Android AppDinesh Prajapati

.NET Fest 2018. Maarten Balliauw. Let’s refresh our memory! Memory management...NETFest

RxJS - The Reactive Extensions for JavaScriptViliam Elischer

JetBrains Australia 2019 - Exploring .NET’s memory management – a trip down m...Maarten Balliauw

My Gentle Introduction to RxJSMattia Occhiuto

Hadoop cluster performance profilerIhor Bobak

Reactive Android: RxJava and beyondFabio Tiriticco

Building Sexy Real-Time Analytics Systems - Erlang Factory NYC / Toronto 2013lpgauth

Functional Reactive Programming / Compositional Event SystemsLeonardo Borges

Performance Monitoring for Docker Environments - Docker Amsterdam June MeetupStijn Polfliet

Quantifying the Performance of Garbage Collection vs. Explicit Memory ManagementEmery Berger

Real world functional reactive programmingEric Polerecky

An Introduction to RxJavaSanjay Acharya

Introduction to c part -3baabtra.com - No. 1 supplier of quality freshers

RxJS and Reactive Programming - Modern Web UI - May 2015Ben Lesh

Debugging Complex Systems - Erlang Factory SF 2015lpgauth

The Popper Experimentation Protocol and CLI toolIvo Jimenez

あなたのScalaを爆速にする７つの方法x1 ichi

Viewers also liked (20)

Android - Preventing common memory leaksAli Muzaffar

Memory leakAnandraj Kulkarni

Memory Leaks in Android ApplicationsLokesh Ponnada

lightning talk : Android memory leakDeivison Sporteman

Memory management for_android_appsBin Shao

- Memory management for Android apps has changed with Gingerbread and Honeycomb, increasing heap sizes and improving garbage collection to reduce pauses - Understanding log messages and using heap dumps can help debug memory issues like leaks caused by lingering references to activities or contexts - The Eclipse Memory Analyzer tool allows inspection of heap dumps to identify dominator trees and retained objects causing leaks

LCA13: Memory Hotplug on AndroidLinaro

Memory hotplug allows increasing or decreasing the amount of memory available at runtime. There are two modes: logical memory hotplug changes availability without hardware changes, while physical hotplug installs/removes DIMMs or NUMA nodes. Mobile devices use memory hotplug to power down memory and save power, but it can take minutes and fail. RAM power management techniques like temperature compensated self refresh, partial array self refresh, and deep power-down can save 5-15% power by automatically or manually powering down RAM chunks when not in use. Proposed approaches include using a memory buffer or balloon driver to reclaim memory for these techniques during suspend without affecting the kernel or user applications. Issues include quality of service, latency

[Vietnam Mobile Day 2013] - Memory management for android applicationsAiTi Education

The document discusses memory management for Android apps. It covers heap size limits which have increased over time from 16MB to 64MB on newer devices. It also discusses garbage collection, noting that earlier versions had stop-the-world pauses over 100ms while newer versions since Gingerbread are concurrent with pauses under 5ms. Bitmap management is also covered, explaining how bitmaps were freed via recycle() before Android 2.3, resulting in full garbage collections, whereas newer versions free bitmaps synchronously during concurrent garbage collection.

Memory management in AndroidKeyhan Asghari

Memory management in AndoidMonkop Inc

Know about Android Operating SystemTrailukya Dutta

Android DesignShyamala Prayaga

This document discusses Android design. It begins by introducing the speaker and outlining the agenda. It then discusses understanding the needs and context of users like persona Rex Lee. It explores Android design challenges related to factors like screen size and typography. It outlines Android design goals such as enchanting users, simplifying their lives, and making them amazing. It stresses focusing on essential use cases, emotional engagement, and taking advantage of mobile opportunities. The document also discusses the process of establishing shared goals, iterating and validating designs, and being user experience advocates.

Memory leak analyseBernd Zuther

Detect all memory leaks with LeakCanary!Pierre-Yves Ricau

Slides for my talk at the Square Presents - Streamlining Android Apps: https://corner.squareup.com/2015/06/streamlining-android-apps.html In just a few few weeks, we reduced by 94% the OutOfMemoryError crashes in the Square Register Android app. We built squ.re/leakcanary to automatically detect memory leaks and make it very easy to fix them. This talk will cover the principles as well as the underlying implementation details. We'll dig into a few interesting examples and lessons learned.

[NEXT] Android Profiler 사용법 YoungSu Son

AsyncTask アンチパターンHiroshi Kurokawa

Memory Management in AndroidOpersys inc.

This document provides an overview of memory management in Android. It begins with an architecture recap and discussion of the kernel's overall role in managing physical memory and virtual address spaces. It then covers key kernel interfaces like memory-mapped registers and DMA. User-space interfaces like brk and mmap are also discussed. The document reviews low-memory conditions and tools for analyzing memory usage at different levels of the Android software stack.

Android memory fundamentalsTaras Leskiv

Memory Management in AndroidOpersys inc.

The document discusses memory management in Android. It begins with required attribution and copyright information for using any content from the slides. It then provides an agenda that outlines the key topics to be covered, including the kernel's role in memory management, kernel and user-space interfaces, low-memory conditions, Bionic, tools for analyzing memory, considerations for app developers, and miscellaneous related topics.

OpenCV IntroductionZachary Blair

Open Source Computer Vision (OpenCV) is a BSD-licensed open source library for computer vision and image processing. The document outlines OpenCV's capabilities including image enhancement, object classification and tracking, and face detection and recognition. It provides examples of using OpenCV in C++ and Python to load and display images, detect faces, and enhance images. The document concludes that OpenCV is a cross-platform library with over 2,000 algorithms for computer vision and image processing tasks.

2015.04.24 Updated > Android Security Development - Part 1: App Development Cheng-Yi Yu

This document discusses various aspects of securing Android app development, including: - Setting debuggable and backup permissions to false to prevent unauthorized access. - Clearing the clipboard when leaving an app to avoid content being copied elsewhere. - Only requesting necessary permissions and removing unneeded ones over time. - Encrypting databases using SQLCipher or the SQLite Encryption Extension. - Verifying SSL certificates and encrypting network traffic using HTTPS. - Performing cryptography in C/C++ via the Android NDK for increased security. - Generating secure access tokens, passwords, and keys using techniques like hardware IDs and scrambling. - Validating user input through secure hashing algorithms.

Android - Preventing common memory leaksAli Muzaffar

Memory leakAnandraj Kulkarni

Memory Leaks in Android ApplicationsLokesh Ponnada

lightning talk : Android memory leakDeivison Sporteman

Memory management for_android_appsBin Shao

LCA13: Memory Hotplug on AndroidLinaro

[Vietnam Mobile Day 2013] - Memory management for android applicationsAiTi Education

Memory management in AndroidKeyhan Asghari

Memory management in AndoidMonkop Inc

Know about Android Operating SystemTrailukya Dutta

Android DesignShyamala Prayaga

Memory leak analyseBernd Zuther

Detect all memory leaks with LeakCanary!Pierre-Yves Ricau

[NEXT] Android Profiler 사용법 YoungSu Son

AsyncTask アンチパターンHiroshi Kurokawa

Memory Management in AndroidOpersys inc.

Android memory fundamentalsTaras Leskiv

Memory Management in AndroidOpersys inc.

OpenCV IntroductionZachary Blair

2015.04.24 Updated > Android Security Development - Part 1: App Development Cheng-Yi Yu

Similar to Identifying memory leaks in Android applications (20)

Sporaroscon2007

The document discusses different tools for finding memory leaks in Java applications. It summarizes the types of tools as inspecting the heap and using instrumentation. Inspecting the heap allows seeing relationships between objects but provides no information on how they got there, while instrumentation identifies objects that may cause leaks but does not show relationships and introduces overhead. The document recommends using both categories of tools and provides examples of profiling tools and case studies of memory leaks discovered.

Memory managementKuban Dzhakipov

This document discusses memory management in Java and analyzing memory usage. It describes the sizes of primitive data types and object headers in Java. It also covers garbage collection, memory leaks if references are not properly cleared, and solutions like SoftReference and WeakReference to help prevent memory leaks. Tools for analyzing heap dumps are presented, including Eclipse Memory Analyzer, which can show histograms of object instances, dominator trees, and paths to GC roots to help debug memory issues.

A topology of memory leaks on the JVMRafael Winterhalter

While most bugs reveal their cause within their stack trace, Java’s OutOfMemoryError is less talkative and therefore regarded as being difficult to debug by a majority of developers. With the right techniques and tools, memory leaks in Java programs can however be tackled like any other programming error. This talks discusses how a JVM stores data, categorizes different types of memory leaks that can occur in a Java program and presents techniques for fixing such errors. Furthermore, we will have a closer look at lambda expressions and their considerable potential of introducing memory leaks when they are used incautiously.

Java Memory Analysis: Problems and Solutions"Mikhail "Misha"" Dmitriev

Memory leak workshopMircea-Andrei Albu

We forget things. It's human. We all have that drawer with useless things that we don't throw away. That's also human. Memory leaks are a combination of these 2 human traits. Forgetting to clean the junk drawer. My good friend Mircea will discuss with you about Java Garbage Collector and some memory leaks you can encounter, sharing from his long experience of performance tuning. Agenda: - GC basic concepts and how it works - Types of references [briefly] - Post Mortem Investigation - Best Practices and Live demo - Preventive Investigation - Best Practices and Live demo

performance optimization: Memory晓东杜

Memory management best practices in Android include using the sparse array family for collections below 1,000 items, avoiding unnecessary object creation, using StringBuilder for string concatenation, properly closing streams to prevent memory leaks, and using patterns like object pools and flyweights to reduce memory usage. The onTrimMemory callback and memory monitoring tools like Memory Monitor and Heap Viewer can help detect memory issues and leaks in an Android application.

Java Garbage Collection, Monitoring, and TuningCarol McDonald

TechGIG_Memory leaks in_java_webnair_26th_july_2012Ashish Bhasin

Memory leaks in Java can occur due to objects remaining reachable even when no longer needed. The four main causes are unknown references, long-living objects, failure to clean up native resources, and bugs. To detect leaks, one can use verbose GC logging, monitor the Java process, dump the heap to analyze which objects are retaining others, and use profiling tools. Profiling works by insertion of code, sampling, or instrumenting the virtual machine and helps identify where time is being spent and what objects are being allocated.

Garbage Collection, Tuning And Monitoring JVM In EBS 11i And R12sidg75

The document discusses garbage collection, tuning, and monitoring the Java Virtual Machine (JVM) in Oracle E-Business Suite 11i and R12. It begins by introducing garbage collection and its role in memory management. It then covers key garbage collection concepts like generations, collectors, and metrics for measurement. The document also lists some notable JVM parameters and provides guidance on monitoring the JVM. It concludes by mentioning future changes related to the JRockit JVM.

Top 5 Java Performance Problems Presentation!Tier1 app

Exploring Java Heap Dumps (Oracle Code One 2018)Ryan Cuprak

Memory leaks are not always simple or easy to find. Heap dumps from production systems are often gigantic (4+ gigs) with millions of objects in memory. Simple spot checking with traditional tools is woefully inadequate in these situations, especially with real data. Leaks can be entire object graphs with enormous amounts of noise. This session will show you how to build custom tools using the Apache NetBeans Profiler/Heapwalker APIs. Using these APIs, you can read and analyze Java heaps programmatically to ask really hard questions. This gives you the power to analyze complex object graphs with tens of thousands of objects in seconds.

C++ memory leak detectionVõ Hòa

Memory leaks occur when a program fails to free memory that is no longer needed, resulting in unused memory increasing over time. This can happen when programmers forget to delete dynamically allocated memory, delete only part of a series of allocations, or have errors in handling pointers. Tools like Visual Leak Detector can detect leaks by tracking memory allocations and deletions, but some leaks may be difficult to find without carefully reviewing code. It is best to organize code well and use techniques like reference counting or garbage collection to prevent leaks.

Eclipse Memory Analyzer Toollittleeye

This document discusses Eclipse Memory Analyzer (MAT), a tool for analyzing memory usage in Android applications. It begins with an overview of MAT and why memory analysis is important for identifying leaks and reducing memory footprint in apps. Key MAT features are demonstrated, including viewing dominator trees, inspecting object fields and collections, class histograms, and grouping by value. The document also covers generating heap dumps from Android devices and investigating object retention paths to find leaks.

Mule memory leak issueJeeHyunLim

This document discusses Java memory leaks. It provides an overview of Java memory management and the behaviors observed with memory leaks. It describes how to generate heap dumps and analyze them using tools like Eclipse Memory Analyzer to identify leaked objects and their referencing paths. Specifically, it outlines how to use MAT to find leak suspects, inspect objects' references, and view thread stacks to locate the root cause of memory leaks.

Effective memory managementYurii Kotov

The document discusses Android memory management and how to avoid memory leaks and OutOfMemoryErrors. It covers topics like Android's memory regions, garbage collection, detecting and avoiding memory leaks, and tools for analyzing memory usage like adb, Android Monitor, Eclipse MAT, and LeakCanary. The document provides tips for avoiding memory leaks such as not keeping long-lived references, using soft/weak references, avoiding unnecessary objects, and implementing onTrimMemory callbacks. It also discusses how to avoid OutOfMemoryErrors by using bitmaps efficiently, sending large files in chunks, checking available heap, and optimizing external library usage.

Effective memory managementDenis Zhuchinski

The document discusses Android memory management and how to avoid memory leaks and OutOfMemoryErrors. It covers topics like application memory restrictions, process priority, garbage collection in Dalvik and ART, detecting and avoiding memory leaks, and tools for analyzing memory usage like adb, Android Monitor, Eclipse MAT, and LeakCanary. The document provides tips on how to avoid memory leaks such as not keeping long-lived references and implementing cancellation policies, and how to avoid OutOfMemoryErrors such as using bitmaps efficiently, recycling bitmaps, avoiding unnecessary object creation, and coordinating with the system using onTrimMemory().

Javasession10Rajeev Kumar

Java manages memory automatically through garbage collection. Objects are stored in heap memory and are eligible for garbage collection when no references to the object exist. The garbage collector runs periodically in its own thread to identify dereferenced objects and free up memory. Programmers cannot force garbage collection but can request it. OutOfMemoryErrors occur when there is insufficient memory for new objects.

(JVM) Garbage Collection - Brown Bag SessionJens Hadlich

Android Memory , Where is all My RAM Yossi Elkrief

This document discusses Android memory management. It explains that Android does not have swap space and relies on garbage collection. It describes the different memory regions in Android including the Java heap, native heap, and ashmem. It provides tips on increasing heap size, viewing heap updates, and how Android manages memory through processes. It also covers topics like memory leaks, references, and tools for analyzing memory usage.

Memory managementmitesh_sharma

This document discusses memory related issues in Android applications. It explains that each app runs in a separate process with limited memory based on the device. If an app demands more memory than the limit, it will crash. Memory leaks and handling large bitmaps can also cause issues. Tools like logcat, MAT, and adb commands can help debug memory problems by analyzing heap dumps and tracking allocations over time.

Sporaroscon2007

Memory managementKuban Dzhakipov

A topology of memory leaks on the JVMRafael Winterhalter

Java Memory Analysis: Problems and Solutions"Mikhail "Misha"" Dmitriev

Memory leak workshopMircea-Andrei Albu

performance optimization: Memory晓东杜

Java Garbage Collection, Monitoring, and TuningCarol McDonald

TechGIG_Memory leaks in_java_webnair_26th_july_2012Ashish Bhasin

Garbage Collection, Tuning And Monitoring JVM In EBS 11i And R12sidg75

Top 5 Java Performance Problems Presentation!Tier1 app

Exploring Java Heap Dumps (Oracle Code One 2018)Ryan Cuprak

C++ memory leak detectionVõ Hòa

Eclipse Memory Analyzer Toollittleeye

Mule memory leak issueJeeHyunLim

Effective memory managementYurii Kotov

Effective memory managementDenis Zhuchinski

Javasession10Rajeev Kumar

(JVM) Garbage Collection - Brown Bag SessionJens Hadlich

Android Memory , Where is all My RAM Yossi Elkrief

Memory managementmitesh_sharma

Recently uploaded (20)

Eating Our Own Dog Food: How to be taken seriously when it comes to adding va...UXPA Boston

As user experience professionals, we've had a better-than-front-row seat when it comes to understanding the humans who try to use our products, services, and platforms. We've been on or in the field, researching users, gaining deep empathy and insights, and finding how to pull business and user needs together, for the happiest Venn diagram since "you got your chocolate in my peanut butter." We've gotten really good at this. When given some room and runway, we've turned journeys that were fraught with friction into seamless experiences for customers, clients, employees, patients, and so many other kinds of users. There's just one problem. Like the accountant, attorney, marketer, and more, we've been struck —mightily — by the curse of knowledge. We have our own jargon, which has become our seemingly secret internal UX code. We can talk in concepts with each other toward great results but, when we talk to our peers, stakeholders, leadership, and others, we forget to tailor our business and technology to their human needs. So they get lost, confused, and frustrated. In these cases, we're providing a terrible user experience. Eating Our Own Dog Food will give you a more objective way to view, talk about, and show the tremendous value that UX brings to the table, in a way that our users in this circumstance can understand it, be energized by it, and be sure to invite us to "the table."

AI and Gender: Decoding the Sociological ImpactSaikatBasu37

Storage Setup for LINSTOR/DRBD/CloudStackShapeBlue

Deciding on a good storage layout is crucial for good performance and reliability on later operations of your LINSTOR/CloudStack installation. This session gave the attendees an overview on different storage setups (LVM-Thin, striping, ZFS) and explaining differences in failure domains and performance implications and how to use them in LINSTOR. -- The CloudStack European User Group 2025 took place on May 8th in Vienna, Austria. The event once again brought together open-source cloud professionals, contributors, developers, and users for a day of deep technical insights, knowledge sharing, and community connection.

Artificial Intelligence (Kecerdasan Buatan).pdfNufiEriKusumawati

Build your own NES Emulator... with KotlinArtur Skowroński

For those who have ever wanted to recreate classic games, this presentation covers my five-year journey to build a NES emulator in Kotlin. Starting from scratch in 2020 (you can probably guess why), I’ll share the challenges posed by the architecture of old hardware, performance optimization (surprise, surprise), and the difficulties of emulating sound. I’ll also highlight which Kotlin features shine (and why concurrency isn’t one of them). This high-level overview will walk through each step of the process—from reading ROM formats to where GPT can help, though it won’t write the code for us just yet. We’ll wrap up by launching Mario on the emulator (hopefully without a call from Nintendo).

A simple Introduction to Algorithmic FairnessPaolo Missier

Assurance Best Practices: Unlocking Proactive Network OperationsThousandEyes

STKI Annual Israel IT Market Study 2025 .Dr. Jimmy Schwarzkopf

MCP Dev Summit - Pragmatic Scaling of Enterprise GenAI with MCPSambhav Kothari

Wondershare Filmora 14.3.2 Crack + License Key Free for Windows PCMudasir

MuleSoft RTF & Flex Gateway on AKS – Setup, Insights & Real-World TipsPatryk Bandurski

This presentation was delivered during the Warsaw MuleSoft Meetup in April 2025. Paulina Uhman (PwC Polska) shared her hands-on experience running MuleSoft Runtime Fabric (RTF) and Flex Gateway on Azure Kubernetes Service (AKS). The deck covers: What happens after installation (pods, services, and artifacts demystified) Shared responsibility model: MuleSoft vs Kubernetes Real-world tips for configuring connectivity Key Kubernetes commands for troubleshooting Lessons learned from practical use cases 🎙️ Hosted by: Patryk Bandurski, MuleSoft Ambassador & Meetup Leader 💡 Presented by: Paulina Uhman, Integration Specialist @ PwC Polska

Building Agents with LangGraph & GeminiHusseinMalikMammadli

Multi-Agent AI Systems: Architectures & Communication (MCP and A2A)HusseinMalikMammadli

Stretching CloudStack over multiple datacentersShapeBlue

In Apache CloudStack, zones are typically perceived as single datacenters. But what if you need to extend your CloudStack deployment across multiple datacenters? How can you seamlessly distribute and migrate virtual machines across them? In this session, Wido den Hollander explored strategies, best practices, and real-world considerations for achieving a multi-datacenter CloudStack setup. -- The CloudStack European User Group 2025 took place on May 8th in Vienna, Austria. The event once again brought together open-source cloud professionals, contributors, developers, and users for a day of deep technical insights, knowledge sharing, and community connection.

PSEP - Salesforce Power of the Platform.pdfssuser3d62c6

This PDF document is a presentation for the Salesforce Partner Success Enablement Program (PSEP), focusing on the "Power of the Platform." It highlights Salesforce’s core platform capabilities, including customization, integration, automation, and scalability. The deck demonstrates how partners can leverage Salesforce’s robust tools and ecosystem to build innovative business solutions, accelerate digital transformation, and drive customer success. It serves as an educational resource to empower partners with knowledge about the platform’s strengths and best practices for solution development and deployment.

AI in Java - MCP in Action, Langchain4J-CDI, SmallRye-LLM, Spring AIBuhake Sindi

Interactive SQL: SQL, Features of SQL, DDL & DMLIsakkiDeviP

Four Principles for Physically Interpretable World Models (poster)Ivan Ruchkin

Presented by: - Jordan Peper and Ivan Ruchkin at ICRA 2025 https://2025.ieee-icra.org/ - Yuang Geng and Ivan Ruchkin at NeuS 2025 https://neus-2025.github.io/ Paper: https://openreview.net/forum?id=bPAIelioYq Abstract: As autonomous robots are increasingly deployed in open and uncertain settings, there is a growing need for trustworthy world models that can reliably predict future high-dimensional observations. The learned latent representations in world models lack direct mapping to meaningful physical quantities and dynamics, limiting their utility and interpretability in downstream planning, control, and safety verification. In this paper, we argue for a fundamental shift from physically informed to physically interpretable world models — and crystallize four principles that leverage symbolic knowledge to achieve these ends: 1. Structuring latent spaces according to the physical intent of variables 2. Learning aligned invariant and equivariant representations of the physical world 3. Adapting training to the varied granularity of supervision signals 4. Partitioning generative outputs to support scalability and verifiability. We experimentally demonstrate the value of each principle on two benchmarks. This paper opens intriguing directions to achieve and capitalize on full physical interpretability in world models.

Dr Schwarzkopf presentation on STKI Summit ADr. Jimmy Schwarzkopf

Introduction and Background: Study Overview and Methodology: The study analyzes the IT market in Israel, covering over 160 markets and 760 companies/products/services. It includes vendor rankings, IT budgets, and trends from 2025-2029. Vendors participate in detailed briefings and surveys. Vendor Listings: The presentation lists numerous vendors across various pages, detailing their names and services. These vendors are ranked based on their participation and market presence. Market Insights and Trends: Key insights include IT market forecasts, economic factors affecting IT budgets, and the impact of AI on enterprise IT. The study highlights the importance of AI integration and the concept of creative destruction. Agentic AI and Future Predictions: Agentic AI is expected to transform human-agent collaboration, with AI systems understanding context and orchestrating complex processes. Future predictions include AI's role in shopping and enterprise IT.

Breaking it Down: Microservices Architecture for PHP Developerspmeth1

Transitioning from monolithic PHP applications to a microservices architecture can be a game-changer, unlocking greater scalability, flexibility, and resilience. This session will explore not only the technical steps but also the transformative impact on team dynamics. By decentralizing services, teams can work more autonomously, fostering faster development cycles and greater ownership. Drawing on over 20 years of PHP experience, I’ll cover essential elements of microservices—from decomposition and data management to deployment strategies. We’ll examine real-world examples, common pitfalls, and effective solutions to equip PHP developers with the tools and strategies needed to confidently transition to microservices. Key Takeaways: 1. Understanding the core technical and team dynamics benefits of microservices architecture in PHP. 2. Techniques for decomposing a monolithic application into manageable services, leading to more focused team ownership and accountability. 3. Best practices for inter-service communication, data consistency, and monitoring to enable smoother team collaboration. 4. Insights on avoiding common microservices pitfalls, such as over-engineering and excessive interdependencies, to keep teams aligned and efficient.

Eating Our Own Dog Food: How to be taken seriously when it comes to adding va...UXPA Boston

AI and Gender: Decoding the Sociological ImpactSaikatBasu37

Storage Setup for LINSTOR/DRBD/CloudStackShapeBlue

Artificial Intelligence (Kecerdasan Buatan).pdfNufiEriKusumawati

Build your own NES Emulator... with KotlinArtur Skowroński

A simple Introduction to Algorithmic FairnessPaolo Missier

Assurance Best Practices: Unlocking Proactive Network OperationsThousandEyes

STKI Annual Israel IT Market Study 2025 .Dr. Jimmy Schwarzkopf

MCP Dev Summit - Pragmatic Scaling of Enterprise GenAI with MCPSambhav Kothari

Wondershare Filmora 14.3.2 Crack + License Key Free for Windows PCMudasir

MuleSoft RTF & Flex Gateway on AKS – Setup, Insights & Real-World TipsPatryk Bandurski

Building Agents with LangGraph & GeminiHusseinMalikMammadli

Multi-Agent AI Systems: Architectures & Communication (MCP and A2A)HusseinMalikMammadli

Stretching CloudStack over multiple datacentersShapeBlue

PSEP - Salesforce Power of the Platform.pdfssuser3d62c6

AI in Java - MCP in Action, Langchain4J-CDI, SmallRye-LLM, Spring AIBuhake Sindi

Interactive SQL: SQL, Features of SQL, DDL & DMLIsakkiDeviP

Four Principles for Physically Interpretable World Models (poster)Ivan Ruchkin

Dr Schwarzkopf presentation on STKI Summit ADr. Jimmy Schwarzkopf

Breaking it Down: Microservices Architecture for PHP Developerspmeth1

Identifying memory leaks in Android applications

1. Identifying memory leaks in Android applications Zachary Blair

2. Doesn’t Java handle memory management?!!!1 http://memegenerator.net/instance/27508171

3. Garbage collection != Immunity from memory leaks!

4. Java/Android Garbage Collection • All objects created with new are stored on the heap • GC periodically disposes of objects that are eligible for garbage collection • Android GC uses a mark-and-sweep algorithm

5. What is “eligible for garbage collection”? • Not reachable from any live threads or any static references − There are no references to the object! • Cyclic references are not counted.

6. What is “eligible for garbage collection”? Simple Example: Integer volume = new Integer(100); Integer System.out.println(volume); 100 volume = null; Volume

7. What is “eligible for garbage collection”? Simple Example: Integer volume = new Integer(100); Integer System.out.println(volume); 100 volume = null; Volume

8. What is “eligible for garbage collection”? Simple Example: Integer volume = new Integer(100); Integer System.out.println(volume); 100 volume = null; null Volume

9. What is “eligible for garbage collection”? Simple Example: Integer volume = new Integer(100); Integer Garbage System.out.println(volume); collected! volume = null; null Volume

10. What is “eligible for garbage collection”? • Lists, Maps, and Sets are prime suspects for memory leaks, because they can accidentally retain references to unused objects! Integer volume = new Integer(100); Integer System.out.println(volume); 100 volumeList.add(volume); null volume = null; Volume volumeList

11. Haiku Break #1 Memory leak, crash. Lingering reference, why!? You make GC cry.

12. Detecting a memory leak Clue #1: Your application crashes with an java.lang.OutOfMemoryError after running for a long time. Clue #2: You see frequent GC_ lines in logcat before the crash. D/dalvikvm( 1325): GC_CONCURRENT freed 1971K, 18% free 12382K/14983K, paused 3ms+7ms Heap statistics Reason for garbage collection: GC_CONCURRENT GC_FOR_MALLOC GC_EXTERNAL_ALLOC GC_HPROF_DUMP_HEAP GC_EXPLICIT

13. Identifying the source of the leak • Step #1 Use DDMS (Dalvik Debug Monitor Server) to dump heap snapshots (an HPROF file) − android-sdkstoolsddms.bat

14. Identifying the source of the leak • Step #2 Use the Android SDK’s “hprof-conv” tool to convert the Android-specific HPROF file into a generic HPROF file that can be analyzed by Eclipse Memory Analyzer

15. Identifying the source of the leak • Step #3 Open the converted HPROF using Eclipse Memory Analyzer

16. Identifying the source of the leak • Step #4 Analyze the results using the “Histogram” view

17. Identifying the source of the leak • Step #4 Analyze the results using the “Histogram” view • Identifies types of objects allocated! • Doesn’t know whether they will eventually be freed! • We must compare two HPROF snapshots to identify which objects are responsible for a leak.

18. Identifying the source of the leak • Step #5 Exercise your app in a way that tends to cause it to exhibit the memory leak, and then use DDMS to dump another heap snapshot • Step #6 Use “hprof-conv” to convert the HPROF file

19. Identifying the source of the leak • Step #7 Open both HPROF files in Eclipse Memory Analyzer and compare their histograms

20. Identifying the source of the leak • Step #7 Open both HPROF files in Eclipse Memory Analyzer and compare their histograms − Compare the number of instances and sizes of each type of object between the two snapshots. − A sustained increase in the number of objects may indicate a leak!

21. Identifying the source of the leak • Step #7 Open both HPROF files in Eclipse Memory Analyzer and compare their histograms − Compare the number of instances and sizes of each type of object between the two snapshots. − An unexplained increase in the number of objects may indicate a leak!

22. Identifying the source of the leak • Step #7 Shallow heap: the size of the objects themselves. Retained heap: the amount that would be freed if we freed these objects (greater than shallow heap because referenced objects may also be freed).

23. Haiku Break #2 Unfreed memory, Delta of two HPROF dumps Who references thou?

24. Fixing the leak • The leak must be the result of unused objects still having references to them so, you can do one of: − Stop creating the objects − Stop maintaining references to the objects − Use weak references (see WeakHashMap) so that those references are invalidated if they are the only ones to the object. − Make sure to close() open streams and connections

25. More Information • Google I/O 2011: Memory management for Android Apps https://www.youtube.com/watch?v=_ CruQY55HOk&feature=relmfu

26. Thank You

Identifying memory leaks in Android applications

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Identifying memory leaks in Android applications (20)

Recently uploaded (20)

Identifying memory leaks in Android applications