• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Java Memeory Overview Public
 

Java Memeory Overview Public

on

  • 11,445 views

a good write-up for jvm memory tuning, by justinchen.

a good write-up for jvm memory tuning, by justinchen.
http://www.blogjava.net/justinchen/archive/2009/03/26/260909.html

Statistics

Views

Total Views
11,445
Views on SlideShare
11,380
Embed Views
65

Actions

Likes
26
Downloads
713
Comments
1

6 Embeds 65

http://www.slideshare.net 54
http://www.linkedin.com 5
http://www.snailee.pe.kr 3
http://translate.googleusercontent.com 1
https://bbpilot.nku.edu 1
https://www.linkedin.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel

11 of 1 previous next

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • good
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Java Memeory Overview Public Java Memeory Overview Public Presentation Transcript

  • Java Memory Management Overview Justin Chen Mar 16 rd , 2009 Justin Chen http://www.blogjava.net/justinchen [email_address] 转载请注明原作者 March 25 th , 2009
  • Before Start … Learning H OW is more important than learning WHAT . 知其然,更要知其所以然
  • Agenda
    • How Java Object Stores in Memory
    • Shallow Size, Retained Size and Weak Reference
    • JVM Memory Structure & Heap Dump
    • How GC works
    • GC Algorithm
    • Hints on GC Turning
    • VisualVM and GCViewer
    • Out of Memory – 3 types
    • Memory Leak, Permanent Memory Leak, Native Memory Leak
    • Memory Leak & Eclipse Memory Analyzer
    • JDK 6
  • Size of Java Types & Objects From Java Spec - byte : 8-bit short : 16-bit Int : 32-bit long : 64-bit char : 16 bit unsigned integer float : 32-bit double: 64-bit boolean: 1 bit? Actual Memory Size - (depends on JVM Implementation) Byte : 16 bytes Short : 16 bytes Integer : 16 bytes Long : 16 bytes Character : 16 bytes Float : 16 bytes Double : 16 bytes Boolean : 16 bytes
    • So, how about Object?
    • new Object()
    • new
    new Object() => 8 bytes new Double[] itself => 16 bytes new ArrayList<Double> itself => 24 bytes Why? Memory Layout of Boolean [HEADER: 8 bytes] 8 [value: 1 byte ] 9 [padding: 7 bytes] 16
  • Shallow and Retained Sizes Shallow Size : the amount of allocated memory to store the object itself. new ArrayList<Boolean>() = 24 bytes Retained Size : shallow size + the shallow sizes of the objects that are accessible, directly or indirectly, only from this object. In other words, the retained size represents the amount of memory that will be freed by the garbage collector when this object is collected. new ArrayList<Boolean>() = 80 bytes What’s GC root?
  • Weak Reference
    • When strong reference are too strong
      • StringBuffer buffer = new StringBuffer();
      • hashMap.put(key, value)
      • cache.add(image)
    • Non-Strong Reference
      • An object referenced only by weak references is considered unreachable (or &quot;weakly reachable&quot;) and so may be collected at any time.
    • Reference Strength: strong > soft > weak > phantom
    • Soft Reference
      • Mostly often used to implement memory-sensitive caches
      • No constraints on GC time, but will be cleared before OOM
    • Weak Reference
      • Weakly reachable object will be discarded at the next GC cycle
    • Phantom Reference
      • An object is phantomly referenced after it has been finalized, but before its allocated memory has been reclaimed.
  • Heap Dump
    • The heap dump is a dump of all the live objects and classes.
      • Example: java_pid460.hprof.20090314.234647
    • The ways to get Heap Dump (Sun Hotspot JVM 5.0 update 16)
      • -XX:+HeapDumpOnOutOfMemoryError
      • -XX:+HeapDumpOnCtrlBreak
      • use profiling tool, such as VisualVM
    • You need a tool to analyze heap dump
      • Runtime Diagram, Visual VM
      • Post-mortem analysis, Eclipse Memory Analyzer
  • JVM Memory Structure User Heap Permanent Native All class instances Arrays -Xmx<size> max New/Old heap size -Xms<size> initial New/Old heap size per-class structures: run-time constant pool, field and method data codes for methods and constructors Interned String -XX:MaxPermSize Eden S0 S1 Old (tenured) GC-able Heap? The memory managed by OS what is interned String? New/Young
  • How GC works? GC of Serial Collection New Object Empty Empty Survivor Spaces Old Eden From To
  • How GC works? Full GC of Serial Collection
    • Full GC: A old or permanent generation collection (Stop the world)
    Before Full GC After Full GC
  • GC Algorithm
    • Serial Collector
      • as we described in previous slides
      • default collector for client-class server
    • Parallel Collector
      • Performing the young generation collection in parallel, old generation is same
      • default collector for server-class server
      • -XX:+UseParallelGC
    • Parallel Compacting Collector
      • Performing the old generation collection in parallel comparing to parallec collector
      • Eventually, this collector will replace Parallel Collector in the future
      • -XX:+UseParallelOldGC
    • Concurrent Mark-Sweep (CMS) Collector (low-latency collector)
      • Shorter GC pauses, but need larger heap space and may cause fragmentation
      • -XX:+UseConcMarkSweepGC
  • GC Algorithm Performance Metrics
    • Throughput – High is better
      • percentage of total time not spent in GC
    • Garbage Collection Overhead
      • percentage of total time spent in GC
    • Pause Time – Low is better
      • the length of Stop Time for GC
    • Frequency of collection
      • how often collection occurs
    • Footprint
      • a measure of size, such as heap size
    • Promptness
      • The time between an object becomes garbage and when the memory becomes available
  • Hints on GC Turning
    • Enough Heap Size
    • The proportion of Heap dedicated to the young generation
      • grant plenty of memory to young generation
      • may cause excessive old generation collections or pause time
    • Specify desired behaviour
      • for parallel collector or parallel compacting collector
      • -XX:MaxGCPauseMillis=n
      • -XX:GCTimeRatio=n 1/(1+n)
    • Diagnosing a Garbage Collection problem
      • http://java.sun.com/docs/hotspot/gc1.4.2/example.html
  • GC Log
    • -Xloggc:d:gc.log
    • -XX:+PrintGC
    • -XX:+PrintGCDetails
    • -XX:+PrintGCTimeStamps – add time stamp
    3603.329: [GC [PSYoungGen: 244309K->4520K(244800K)] 705465K->472071K(978816K), 0.0274399 secs] Young Gen: before GC->After GC All: before GC->after GC Pause Time 3603.357: [Full GC [PSYoungGen: 4520K->0K(244800K)] [PSOldGen: 467550K->407305K(734016K)] 472071K->407305K(978816K) [PSPermGen: 81712K->81712K(171136K)], 1.3827685 secs]
  • Visual VM
    • Get Runtime Heap Dump
    • Monitor
    • Visual GC
    time spent compiling Java byte codes into native code TenuringThreshold & MaxTenuringThreshold also impacts performance
  • GC Viewer - Post-mortem analysis
  • Out of Memory - java.lang.OutOfMemoryError
    • Java heap space
      • Configuration issue: -Xmx
      • Memory Leak
      • The excessive use of finalizers
    • PermGen space
      • Too many classes: -XX:MaxPermSize
    • Requested array size exceeds VM limit
      • Why need a so big array?
    • Request <size> bytes for <reason>. Out of swap space?
      • Native Memory Leak?
    • <reason> <stack trace> (Native method)
      • Native Memory Allocation Issue
  • Memory Leak vs. OOM
    • Memory Leak (OOM != Memory Leak)
      • An unintentional memory usage.
      • Java memory leaks are objects which are not used/needed anymore, but which are still reachable and therefore are not removed by the Garbage Collector.
    • How Can We Find Leak
      • In most of cases, the biggest objects
    • Who Caused Leak?
      • follow the reference chain from the object to the (GC) roots
    • GC Roots
      • Objects on the call stack of the current thread (e.g. method parameters and local variables)
      • The thread itself and classes loaded by the system class loader
      • custom class loaders are NOT
  • Eclipse Memory Analysis – Heap Memory Leak
  • Perm Memory Leak
    • Too Many Interned String
      • String.intern()
      • Constant String will be interned implicitly
      • No Enough Info provided by Heap Dump on Interned String
      • If Perm Memory increased dynamically, be careful
    • Too Many Classes or Class Load Leak
      • Enlarge the perm generation
      • Avoid duplicated class loader
  • Eclipse Memory Analyzer – Perm Generation
    • Class Loader Explorer: Java Basic => Class Load Explorer
    Class Loader Name Loaded Class Number Loaded Object Number
  • List Duplicated Class Loaders
    • Java Basic => Duplicated Classes
  • Out of Swap Space?
    • Request <size> bytes for <reason>. Out of swap space?
      • Enlarge the swap space
      • Systems with 4GB of ram or less require a minimum of 2GB of swap space
      • Systems with 4GB to 16GB of ram require a minimum of 4GB of swap space
      • For Unix Family OS, use pmdump or pmap, libumem for Solaris
    # An unexpected error has been detected by SAP Java Virtual Machine: # java.lang.OutOfMemoryError: requested 2048000 bytes for eArray.cpp:80: GrET*. Out of swap space or heap resource limit exceeded (check with limits or ulimit)? # Internal Error (..hotspotsrcsharevmmemoryallocation.inline.hpp, 26), pid=6000, tid=468
  • Native Memory Leak?
    • <reason> <stack trace> (Native method)
      • Native Memory Allocation Issue
    • C heap exhaustion is usually the result of a memory leak in either
      • VM itself
      • Core library native code
      • Third party native code
    • Append -verbose:jni option after JVM args.
      • Observe the loading and linking actions of jni dynamic libs
    • No many choices
      • Check JVM bugs
  • JDK 6 ! – Performance Enhancement
    • Runtime Performance Improvement
      • Synchronization & Multiple Threads
      • Array Copy
      • Background compilation (Runtime Code Optimization)
    • GC Performance Improvement
      • Parallel Compaction Collector
      • Concurrent Low Pause Collector
  • Last but not least
    • Let’s use powerful machine
      • 64 bit
      • 4 - 8 CPU
      • 16GB – 64GB Memory
    • Unix Family OS
      • Why Java Runs on Windows?
      • Solaris
      • HP-UX
      • Unit
      • Linux
    • However, Hardware cannot help you survive if the codes are rubbish!
  • References
    • http://www.codeinstructions.com/2008/12/java-objects-memory-structure.html
    • http://wiki.eclipse.org/index.php/MemoryAnalyzer
    • http://dev.eclipse.org/blogs/memoryanalyzer/2008/04/21/immortal-objects-or-how-to-find-memory-leaks/
    • http://java.sun.com/javase/technologies/hotspot/gc/index.jsp
    • http://java.sun.com/javase/technologies/hotspot/gc/memorymanagement_whitepaper.pdf
    • http://www.tagtraum.com/gcviewer-vmflags.html#sun.verbose
    • http://java.sun.com/javase/technologies/hotspot/vmoptions.jsp
    • http://java.sun.com/performance/reference/whitepapers/6_performance.html#2
    • http://java.sun.com/docs/hotspot/gc1.4.2/example.html
    • http://blogs.sun.com/dagastine/entry/java_6_leads_out_of
    • http://weblogs.java.net/blog/enicholas/archive/2006/05/understanding_w.html