The document discusses Java memory management and garbage collection. It describes the responsibilities of garbage collection as allocating memory, ensuring referenced objects remain in memory, and recovering memory from unreachable objects. It discusses generation collection and the Hotspot memory model with young and old generations. The major garbage collectors are described as serial, parallel, parallel compacting, and concurrent mark-sweep collectors. The document provides examples of VM options and logging output.

1. Tech shareJava Memory Management

2. Garbage Collection Responsibility Allocating memoryEnsuring that any referenced objects remain in memoryRecovering memory used by objects that are no longer reachable from references in executing code.

3. Generation CollectionMost allocated objects die youngFew references from older to younger objects exist.

4. Sun hotspot memory modelYoung GenerationEdenSurvivor FromSurvivor ToTenured (Old) GenerationPermanentobjects describing classes and methodsas well as the classes and methods themselves

5. Garbage Collection Typesyoung generation collection (minor collection)young generation fills upfull collection (major collection) old or permanent generation fills upSystem.gc()the old generation collection algorithm is used on : Sometimes the old generation is too full to accept all the objects that would be likely to be promoted from the young generation to the old generation if the young generation was collected first.

6. Fast Allocationbump-the-pointer technique large contiguous blocks of memory availableThread-Local Allocation Buffers (TLABs)multithread-safewithout global locks-XX:TLABWasteTargetPercent (n/Eden) -XX:+PrintTLAB

7. Hotspot CollectorsSerial CollectorParallel CollectorParallel Compacting CollectorConcurrent Mark-Sweep (CMS) Collector

8. Hotspot Default garbage collector Java –versionjava version "1.6.0_23"Java(TM) SE Runtime Environment (build 1.6.0_23-b05)Java HotSpot(TM) Client VM (build 19.0-b09, mixed mode, sharing) Server : parallel collectorNote: For Java SE 6, the definition of a server-class machine is one with at least 2 CPUs and at least 2GB of physical memory.Client: Serial collector

9. Serial Collectorusing a single CPUin a stop-the-world fashion

10. Serial CollectorYong Generation Collectiontoo large objects are directly copied to old generation-XX:InitialTenuringThreshold=7-XX:MaxTenuringThreshold=

11. Serial Collector Old Generation Collectionmark-sweep-compactMarkMark live objectsSweepSweep unmarked objectsCompactFor bump-the-pointer

12. Serial CollectorWhen to Use:do not have a requirement for low pause timesOn today’s hardware, less than half a second for full collections (64MB heaps)1024MB/64MB=16*0.5second = 8secondUsage:-XX:+UseSerialGC

13. Parallel Collectoralso known as the throughput collector-XX:+PrintGCDetails -XX:+PrintTLAB -XX:MaxTenuringThreshold=7 -XX:PretenureSizeThreshold=2M -XX:+PrintGCTimeStamps -Xms30M -Xmx30M -Xmn2M -XX:+UseParallelGCPSYoungGen [0x085f0000, 0x087f0000, 0x087f0000)eden space [0x085f0000,0x087673c0,0x08770000) from space [0x087b0000,0x087b0000,0x087f0000) to space [0x08770000,0x08770000,0x087b0000)PSOldGen [0x069f0000, 0x085f0000, 0x085f0000) object space [0x069f0000,0x070f0070,0x085f0000)

14. Parallel CollectorYoung Generation Collectionstill a stop-the-world and copying collectorin parallelusing many CPUs

15. Parallel CollectorOld Generation CollectionStill mark-sweep-compact serial operationWhen to use:often appropriate include those that do batch processing, billing, payroll, scientific computing, and so on.Usage:-XX:+UseParallelGC

16. Parallel Compacting Collectorwas introduced in J2SE 5.0 update 6Note: willreplace the parallel collector.Young Generation Collection Same as parallel collector

17. Parallel Compacting CollectorOld Generation Collection marking phaselogically divided into fixed-sized regionsGCmarklive objects with multi-thread–XX:ParallelGCThreads=n (By default on a host with N CPUs)summary phase (serial operation)starting with the leftmost one to examine the density of the regionsCalculates and stores the new location of the first byte of live data for each compacted regioncompaction phaseCompact use by summary data

18. Parallel Compacting CollectorWhen to use:more than one CPUreduces pause times (multi-thread)Usage:-XX:+UseParallelOldGC-XX:ParallelGCThreads=n

19. Concurrent Mark-Sweep (CMS) Collectoralso known as the low-latency collector.Young Generation Collection Same as parallel collector

20. Concurrent Mark-Sweep (CMS) CollectorOld Generation Collection:identifies the initial set of live objects directly reachable from the application codemarks all live objects that are transitively reachable from this set

21. Concurrent Mark-Sweep (CMS)disadvantageonly collector that is non-compactingrequirement for larger heap sizes than the other collectorsCMS Incremental Modeperiodically stopping the concurrent phase toyield back processing to the application–XX:+CMSIncrementalMode

22. Concurrent Mark-Sweep (CMS)When to use:applications that have a relatively large set of long-lived data (a large old generation)run on machines with two or more processorsfor any application with a low pause time requirementUsage: -XX:+UseConcMarkSweepGC–XX:+CMSIncrementalMode (Incremental Mode)

23. CMS log2.259: [GC [1 CMS-initial-mark: 4280K(5120K)] 6042K(18944K), 0.0003876 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 2.260: [CMS-concurrent-mark-start]2.267: [CMS-concurrent-mark: 0.007/0.007 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 2.267: [CMS-concurrent-preclean-start]2.267: [CMS-concurrent-preclean: 0.001/0.001 secs] [Times: user=0.01 sys=0.00, real=0.02 secs] 2.267: [GC[YG occupancy: 1761 K (13824 K)]2.268: [Rescan (parallel) , 0.0001977 secs]2.268: [weak refs processing, 0.0000046 secs] [1 CMS-remark: 4280K(5120K)] 6042K(18944K), 0.0003386 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 2.268: [CMS-concurrent-sweep-start]2.269: [CMS-concurrent-sweep: 0.001/0.001 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 2.269: [CMS-concurrent-reset-start]2.269: [CMS-concurrent-reset: 0.001/0.001 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

24. Disadvantage of non-compactingCodestatic int alloc_1MB = 1024 * 1024 * 1;public static void main(String[] args) throws Exception { //UseConcMarkSweepGC byte[] bytes10 = alloc(); alloc(); byte[] bytes12 = alloc(); alloc(); byte[] bytes14 = alloc(); alloc(); byte[] bytes16 = alloc(); alloc(); byte[] bytes18 = alloc(); alloc(); byte[] bytes20 = alloc(); alloc(); byte[] bytes22 = alloc();alloc(3); }static int count = 0; private static byte[] alloc() { return alloc(1); } private static byte[] alloc(inti) { count = count + 1 * i ;System.out.println(count + "M"); return new byte[alloc_1MB * i]; }

25. Disadvantage of non-compactingresult of Parallel&ParallelOld-XX:+UseParallelGC -XX:PretenureSizeThreshold=1k -XX:MaxTenuringThreshold=30 -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:-PrintTenuringDistributionPSYoungGen total 8960K, used 5336Keden space 7680K, 69% used from space 1280K, 0% used to space 1280K, 0% used PSOldGen total 10240K, used 6598K object space 10240K, 64% usedPSPermGen total 16384K, used 4969K object space 16384K, 30% used

26. Disadvantage of non-compactingResult of CMS-XX:+UseConcMarkSweepGC -XX:PretenureSizeThreshold=1k -XX:MaxTenuringThreshold=30 -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:-PrintTenuringDistributionException in thread "main" java.lang.OutOfMemoryError: Java heap space par new generation total 9216K, used 491K eden space 8192K, 6% used from space 1024K, 0% used to space 1024K, 0% used concurrent mark-sweep generation total 10240K, used 398K concurrent-mark-sweep perm gen total 16384K, used 4947K

27. VM options-XX:MaxGCPauseMillis=nPause time-XX:GCTimeRatio=991 / (1 + n)Throughput-Xmx –Xms-Xmn (=eden+survivor*2)–XX:SurvivorRatio=32 (1:34)Survivor:Eden-XX:MaxPermSize

28. Print gc–XX:+PrintGC–XX:+PrintGCDetails–XX:+PrintGCTimeStamps-verbose:gc[GC 325407K->83000K(776768K), 0.2300771 secs][GC 325816K->83372K(776768K), 0.2454258 secs][Full GC 267628K->83769K(776768K), 1.8479984 secs]

29. example-XX:MaxTenuringThreshold=7-XX:MaxTenuringThreshold=0 -Xms30M -Xmx30M -Xmn10M -XX:+UseSerialGC def new generation total 9216K, used 1106K [0x30be0000, 0x315e0000, 0x315e0000)eden space 8192K, 13% used [0x30be0000, 0x30cf4830, 0x313e0000)from space 1024K, 0% used [0x314e0000, 0x314e0000, 0x315e0000) to space 1024K, 0% used [0x313e0000, 0x313e0000, 0x314e0000)-XX:MaxTenuringThreshold=0-XX:MaxTenuringThreshold=7 -Xms30M -Xmx30M -Xmn10M -XX:+UseSerialGC def new generation total 9216K, used 1292K [0x30be0000, 0x315e0000, 0x315e0000)eden space 8192K, 13% used [0x30be0000, 0x30cf4890, 0x313e0000)from space 1024K, 18% used [0x314e0000, 0x3150e8b0, 0x315e0000) to space 1024K, 0% used [0x313e0000, 0x313e0000, 0x314e0000)Error example-XX:MaxTenuringThreshold=0 –Xms20M –Xmx20M -Xmn18M -XX:+UseSerialGCException in thread "main" java.lang.OutOfMemoryError: Java heap spaceNotice:for Serial collector & CMS

30. System.gc() & finalize()Code:public class SerialTest { public static void main(String[] args) throws Exception { new SerialTest();System.gc();Thread.sleep(10);System.out.println("123"); }@Override protected void finalize() throws Throwable {System.out.println("heloo================finalize"); }}Result:0.227: [Full GC (System) TLAB: gc thread: 0x08839400 [id: 5820] ………..heloo================finalize123

31. finalize twice GC !!!

32. monitorJVisualVMJConsoleJRockit mission control

33. Garbage-First Garbage CollectorG1 GC for shortIs a new GC that is being introduced in the Java HotSpot VM in JDK 7also been released in Java SE 6 Update 14. G1 is the long-term replacement for HotSpot's low-latency Concurrent Mark-Sweep GC (widely referred to as CMS).

34. Garbage-First Garbage CollectorParallelism and Concurrency.G1 performs heap compactionthere is a single contiguous heap which is split into same-sized regionsYoung/old generation is a set of potentially non-contiguous regions

35. G1 CollectorHeap garbage-first heap total 20480K, used 3491K region size 1024K, 3 young (3072K), 0 survivors (0K) compacting perm gen total 16384K, used 4967K the space 16384K, 30% usedNo shared spaces configured.

36. G1 CollectorRS: regon set0.634: [GC pause (young), 0.00846287 secs] [Parallel Time: 8.3 ms] [GC Worker Start Time (ms): 633.9 634.3] [Update RS (ms): 0.0 0.0Avg: 0.0, Min: 0.0, Max: 0.0] [Processed Buffers : 0 5 Sum: 5, Avg: 2, Min: 0, Max: 5] [Ext Root Scanning (ms): 3.6 3.3Avg: 3.5, Min: 3.3, Max: 3.6] [Mark Stack Scanning (ms): 0.0 0.0Avg: 0.0, Min: 0.0, Max: 0.0] [Scan RS (ms): 0.0 0.0Avg: 0.0, Min: 0.0, Max: 0.0] [Object Copy (ms): 3.8 3.6Avg: 3.7, Min: 3.6, Max: 3.8] [Termination (ms): 0.0 0.0Avg: 0.0, Min: 0.0, Max: 0.0] [Termination Attempts : 1 1 Sum: 2, Avg: 1, Min: 1, Max: 1] [GC Worker End Time (ms): 641.3 641.3] [Other: 1.1 ms] [Clear CT: 0.0 ms] [Other: 0.2 ms] [Choose CSet: 0.0 ms] [ 2868K->1763K(20M)] [Times: user=0.00 sys=0.00, real=0.00 secs]

37. comparison

38. referenceshttp://java.sun.com/products/hotspot/whitepaper.htmlhttp://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.htmlhttp://blogs.oracle.com/watt/resource/jvm-options-list.htmlhttp://www.iteye.com/topic/802638http://blog.csdn.net/calvinxiu/archive/2007/05/18/1614473.aspxhttp://unixboy.iteye.com/blog/174173http://java.sun.com/performance/reference/whitepapers/tuning.html