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.

1. Memory Management
Kuban Dzhakipov
@Sibers
2012

2. Plan
● introduction
● fundamentals
● solutions via WeakReference, SoftReference, etc
● analyze tools

3. Memory Usage
8 primitive data types:
Integers:
● byte
● short - 2 bytes
● int - 4 bytes
● long - 8 bytes
Floating-point number:
● float 4 bytes
● double 8 bytes
Characters:
● char - 2 bytes (utf16)
Boolean
● boolean - 1 byte (1 byte versus 1 bit, alternative BitSet)

4. Memory Usage
Object Shallow size = object header + object fields
Object header:
● Hash Code
● Garbage Collection Information
● Type Information Block Pointer
● Lock
● ArrayLength
object header size:
* 32bit - 8 bytes
* 64bit - 16 bytes

5. Memory Usage
1. public final class String { //8 bytes
2. private char value[]; // 4 bytes
3. private int offset; // 4bytes
4. private int count; //4 bytes
5. private int hash; //4 bytes
6. }
7.
8. // Shallow size of a String = 24 bytes
9. // Davlik VM for ARM
10.
11. * 32 bit architecture

6. Memory Usage
new String() // 24 bytes
new String("a") // 40 bytes
new char[1]
Object Header: 12 bytes
Data type char: 2 bytes
Offset : 2 bytes
Total: 16 bytes
new String("a") == 40 bytes
* 32 bit architecture
* 64 bit architecture = 40+16=56bytes

7. GC

9. GC
1. for(int z=0; z < 10000; z++){
2. SomeClass a = new SomeClass();
3. a.doSomething();
4. for(int i=0; i<100;i++; i++){
5. StringBuilder str = new StringBuilder();
6. str.append("This is #");
7. str.append(i);
8. System.out.println(str.toString());
9. }
10. }
11. .......
12. // collects objects by gc

10. Memory Leak
1. // example #1
2. ArrayList least = new ArrayList();
3. for(int i=0; i<10000; i++){
4. String n = "something"; // couldn't be destroyed by gc
5. least.add(n);
6. }
....* least is property of object
7. //example #2
8. @Override
9. protected void onCreate(Bundle state) {
10. super.onCreate(state);
11.
12. TextView label = new TextView(this);
13. label.setText("Leaks are bad");
14.
15. setContentView(label);
16. }

11. Memory Leak
// strong reference

12. OutOfMemoryError?

13. Solutions
● SoftReference
● WeakReference
● PhantomReference

14. SoftReference
1. SoftReference<List<Foo>> ref = new SoftReference<List<Foo>>
(new LinkedList<Foo>()); // create some Foos, probably in a loop
2. List<Foo> list = ref.get();
3. if (list == null) throw new RuntimeException("ran out of memory");
4. list.add(foo);

15. WeakReference
1. WeakReference<List<Foo>> ref = new WeakReference<List<Foo>>
(new LinkedList<Foo>()); // create some Foos, probably in a loop
2. List<Foo> list = ref.get();
3. if (list == null) throw new RuntimeException("ran out of memory");
4. list.add(foo);

16. PhantomReference
1. PhantomReference<List<Foo>> ref =
new PhantomReference<List<Foo>>(new LinkedList<Foo>(), new ReferenceQueue<List<Foo>>());
// create some Foos, probably in a loop
2. List<Foo> list = ref.get(); // always return null

17. Memory Analyze Tool
JHat
JProfiler
Eclipse Memory Analyzer
Yourkit
Netbeans

18. Eclipse Memory Analyzer
Information available on
http://eclipse.org/mat/

19. Get a Heap
● jconsole
● jmap
● ddms(android)

20. Overview

21. Histogram

22. Dominator Tree

23. Path to GC Roots

24. GC Roots
The so-called GC (Garbage Collector) roots are objects special for garbage collector. Garbage collector collects those objects
that are not GC roots and are not accessible by references from GC roots.
There are several kinds of GC roots. One object can belong to more than one kind of root. The root kinds are:
● Class - loaded class. Classes can hold objects via static fields.
● Alive Threads
● Stack Local - local variable or parameter of method.
● Finalizer Queue Entry - object scheduled for finalization.
● GC Handle - provides a means for accessing a managed object from unmanaged memory.
● Other - objects hold from garbage collection by CLR for other reasons.

25. Summary

26. ?

27. Thanks for your time!
Sources:
d.android.com
habrahabr.ru
eclipse.org/mat