Memory management
1 like730 views
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.
![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](https://image.slidesharecdn.com/memorymanagement1-120119094256-phpapp01/85/Memory-management-5-320.jpg)
![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](https://image.slidesharecdn.com/memorymanagement1-120119094256-phpapp01/85/Memory-management-6-320.jpg)
Memory management
- 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
- 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