Java 5 6 Generics, Concurrency, Garbage Collection, Tuning

J2SE 5.0, 6.0 Generics Concurrency, Garbabe Collection Carol McDonald Java Technology Architect Sun Microsystems, Inc.

Speaker’s Qualifications Carol cDonald: Java Architect at Sun Microsystems Before Sun, worked on software development of: Application to manage car Loans for Toyota (>10 million loans) Pharmaceutical Intranet ( Roche Switzerland) Telecom Network Mgmt ( Digital France) X.400 Email Server ( IBM Germany)

Agenda Language Changes Generics & Metadata Library API Changes Concurrency utilities Garbage Collection Virtual Machine Monitoring & Management Next Release: Mustang

J2SE 5.0 Design Themes Focus on quality , stability, compatibility Big emphasis on scalability exploit big heaps, big I/O, big everything Ease of development Faster, cheaper, more reliable

Java Language Changes JDK 1.0 Initial language, very popular JDK1.1 Inner classes, new event model JDK 1.2, 1.3 No changes at language level JDK 1.4 Assertions (minor change) JDK 5.0 Biggest changes to language since release 1.0

2004 2006 J2SE 5 “ Tiger” Java SE 6 “ Mustang” 2007 Java SE 7 “ Dolphin” Java SE road map 2008 2003 2002 2005 J2SE 1.4 EOL J2SE 1.3.1 5.0 Java SE 5 2004/9 1. 6 .0 Java SE 6 2006/12 1. 7 .0 Java SE 7 2008

Tiger Is Everywhere Tiger 1.4.x Completed downloads per month

Over 262,295,496 downloads served! Tiger Is Everywhere

Pre-installed on > 60 % of new PCs Tiger Is Everywhere

≥ 99.999 % availability Previous best: 99.98% for 1.4.2 Tiger Is Stable

Tiger Is Fast Server Benchmark: SPECjbb2000

Tiger [Java SE 5] Features Overview JDK 6 Features Overview

Seven Major New Features Generics Autoboxing/Unboxing Enhanced for loop (“foreach”) Type-safe enumerations Varargs Static import Metadata

Is there a problem in here? Vector v = new Vector(); v.add(new Integer (4)); OtherClass.expurgate(v); ... static void expurgate(Collection c) { for (Iterator it = c.iterator(); it.hasNext();) if ((( String )it.next()).length() == 4) it.remove(); }

The Problem (Pre-J2SE 5.0) Vector v = new Vector(); v.add(new Integer (4)); OtherClass.expurgate(v); ... static void expurgate(Collection c) { for (Iterator it = c.iterator(); it.hasNext();) /* ClassCastException */ if ((( String )it.next()).length() == 4) it.remove(); }

Generics Problem: Collection element types Compiler is unable to verify types Assignment must use the cast operator This can generate runtime errors ( ClassCastException ) Solution: Tell the compiler what type the collection is Let the compiler fill in the cast

Using Generic Classes Instantiate a generic class to create type specific object Example Vector <String> x = new Vector <String> (); x.add(new Integer(5)); // Compiler error! Vector <Integer> y = new Vector <Integer> ();

Wildcards Method to print contents of any Collection? Wrong! Passing a Collection of type String will give a compiler error void printCollection(Collection <Object> c) { for (Object o : c) System.out.println( o ); }

Wildcards Correct way: ? is the wildcard type Collection <?> means Collection of unknown void printCollection( Collection <?> c) { for (Object o : c) System.out.println(o); }

Bounded Wildcards A wildcard can be specified with an upper bound public void drawAll (List< ? extends Shape >s) { ... } List<Circle> c = getCircles(); drawAll(c) ; List<Triangle> t = getTriangles(); drawAll(t) ;

Autoboxing/Unboxing of Primitive Types Problem: (pre-J2SE 5.0) Conversion between primitive types and wrapper types (and vice-versa) must manually convert a primitive type to a wrapper type before adding it to a collection int i = 22; List l = new LinkedList(); l.add( new Integer(i) );

Autoboxing/Unboxing of Primitive Types Solution: Let the compiler do it Integer intObj = 22 ; // Autoboxing conversion int i = intObj; // Unboxing conversion ArrayList< Integer > al = new ArrayList<Integer>(); al .add( i ); // Autoboxing conversion

Enhanced for Loop (foreach) Problem: (pre-J2SE 5.0) Iterating over collections is tricky Often, iterator only used to get an element Iterator is error prone (Can occur three times in a for loop) Solution: Let the compiler do it New for loop syntax for (variable : collection) Works for Collections and arrays

Enhanced for Loop Example Old code pre-J2SE 5.0 void cancelAll(Collection c) { for ( Iterator i = c.iterator(); i.hasNext() ; ){ TimerTask task = (TimerTask) i.next(); task.cancel(); } } New Code void cancelAll(Collection <TimerTask> c) { for ( TimerTask task : c ) task.cancel(); } Iterating over collections, tricky, error prone New for loop syntax: Let the compiler do it Works for Collections and arrays

Type-safe Enumerations Problem: (pre-J2SE 5.0) to define an enumeration: Defined a bunch of integer constants: public static final int SEASON_WINTER = 0; public static final int SEASON_SPRING = 1; Issues of using Integer constants Not type safe (any integer will pass),Brittleness (how do add value in-between?), Printed values uninformative (prints just int values) Solution: New type of class declaration enum type has public, self-typed members for each enum constant enum Season { WINTER, SPRING, SUMMER, FALL }

Enumeration Example: public class Card { public enum Suit { spade, diamond, club, heart }; public enum Rank { ace, two, three, four, five, six, seven, eight, nine, ten, jack, queen, king }; private Card (Rank rank, Suit suit) { this.rank = rank; this.suit = suit; } } List< Card > deck = new ArrayList< Card >(); for ( Suit suit : Suit.values ()) for ( Rank rank : Rank.values ()) deck.add(new Card(rank, suit)); Think how much JDK1.4 code this would require!

Before Varargs Example //example method that takes a variable number of parameters int sum( Integer[] numbers ) { for(int i: numbers) // do something } // Code fragment that calls the sum method sum( new Integer[] {12,13,20} ); http://www.javaworld.com/javaworld/jw-04-2004/jw-0426-tiger1.html Problem: (in pre-J2SE 5.0) To have a method that takes a variable number of parameters Can be done with an array, but caller has to create the array first

Varargs Example (Cont) //example method that takes a variable number of parameters int sum ( Integer... numbers ) { for(int i: numbers) // do something } // Code fragment that calls the sum method sum( 12,13,20 ); http://www.javaworld.com/javaworld/jw-04-2004/jw-0426-tiger1.html Solution: Let the compiler do it for you: String format (String fmt, Object... args); Java now supports printf(...)

Varargs examples APIs have been modified so that methods accept variable-length argument lists where appropriate Class.getMethod Method.invoke Constructor.newInstance Proxy.getProxyClass MessageFormat.format New APIs do this too System.out. printf (“%d + %d = %d\n”, a, b, a+b);

Static Imports Problem: (pre-J2SE 5.0) Having to fully qualify every static referenced from external classes Solution: New import syntax import static TypeName.Identifier; import static Typename.*; Also works for static methods and enums e.g Math.sin(x) becomes sin(x)

Simple Formatted I/O Printf is popular with C/C++ developers Powerful, easy to use Finally adding printf to J2SE 5.0 (using varargs) out.printf(“%-12s is %2d long”, name, l); out.printf(“value = %2.2F”, value);

Annotations Metadata (JSR-175) Provide standardised way of adding annotations to Java code public @Remote void foo() {} Annotations are used by tools that work with Java code: Compiler IDE Runtime tools Used to generate interfaces, deployment descriptors...

Annotations Example: JAX-RPC Old Code public interface PingIF implements java.rmi.Remote { public void foo() throws java.rmi.RemoteException; } public class Ping implements PingIF { public void foo() {...} } New Code public class Ping { public @Remote void foo() {} }

Some Performance Enhancements in JDK 1.4 java.nio package Non blocking I/O : improved performance in buffer management, scalable network and file i/o Reflection Many reflective operations rewritten for higher performance (20x)

Some J2SE 5.0 Performance Features Concurrency libraries Garbage collection improvements “ Smart tuning” Small systems performance optimizations Client features Class data sharing Various JFC/Swing and Java 2D™ APIs improvements X86 Optimizations

Quick Performance Fix Always upgrade to the latest version of the JDK/JRE Sun is always working to improve performance Sun is always working to reduce the number of 'undocumented features'

Tiger is Fast Client Benchmark: SwingMark

x64 SPECjbb2005 Performance SPECjbb2005 Sun Fire X4100 (2 chip, 2 core, 2 threads) 32,018 SPECjbb2005 bops, 32,018 SPECjbb2005 bops/JVM, Sun Fire X4100 (2 chip, 2 core, 2 threads) 38,090 SPECjbb2005 bops, 19,045 SPECjbb2005 bops/JVM, submitted for review, IBM eServer p5 510 (2 chips, 2 cores, 4 thread) 36,039 bops, 36,039 bops/JVM, Dell SC1425 (2 chips, 2 cores, 4 thread) 24,208 SPECjbb2005 bops, 24,208 SPECjbb2005 bops/JVM, Dell PE 850 (1 chip, 2 cores, 2 thread) 31,138 SPECjbb2005 bops, 31,138 SPECjbb2005 bops/JVM. SPEC® and the benchmark name SPECjbb™ are trademarks of the Standard Performance Evaluation Corporation. Competitive benchmark results stated above reflect results published on www.spec.org as of May 11, 2005. For the latest SPECjbb2005 benchmark results, visit http://www.spec.org/osg/jbb2005. Sun Fire™ X4100 Server Wins

Java is Fast! Grizzly Web Server Benchmark

Motivation for Concurrency Utilities Developing concurrent classes was too hard Java has concurrency primitives: wait() , notify() , sleep() , interrupt() , synchronized These are too primitive, Too low level Easy to use incorrectly Incorrect use can produce poor performance

Concurrency Utilities Goals Provide a good set of concurrency building blocks library for concurrency like Collections for data structures Enhance scalability, performance, readability and thread safety of Java applications Beat C performance in high-end server applications

Puzzle: “Ping Pong” 01 class PingPong { 02 public static synchronized void main (String[] a) { 03 Thread t = new Thread() { 04 public void run() { 05 pong(); 06 } 07 }; 08 09 t.run(); 10 System.out.print("Ping"); 11 } 12 13 static synchronized void pong() { 14 System.out.print("Pong"); 15 } 16 }

What Does It Print? (a) PingPong (b) PongPing (c) It varies

What Does It Print? (a) PingPong (b) PongPing (c) It varies Not a multithreaded program!

Example How to start a thread public class HelloRunnable implements Runnable { public void run() { System.out.println("Hello from a thread!"); } public static void main(String args[]) { (new Thread (new HelloRunnable())) .start(); } }

Another Look 01 class PingPong { 02 public static synchronized void main(String[] a) { 03 Thread t = new Thread() { 04 public void run () { 05 pong(); 06 } 07 }; 08 09 t. run (); // Common typo! 10 System.out.print("Ping"); 11 } 12 13 static synchronized void pong() { 14 System.out.print("Pong"); 15 } 16 }

How Do You Fix It? 01 class PingPong { 02 public static synchronized void main(String[] a) { 03 Thread t = new Thread() { 04 public void run() { 05 pong(); 06 } 07 }; 08 09 t. start (); 10 System.out.print("Ping"); 11 } 12 13 static synchronized void pong() { 14 System.out.print("Pong"); 15 } 16 }

The Moral Invoke Thread.start , not Thread.run Common error Can be very difficult to diagnose

Concurrency Utilities: JSR-166 Task Scheduling Framework: Executor interface replaces direct use of Thread Callable and Future Synchronisers Semaphore, CyclicBarrier, CountDownLatch Concurrent collections : BlockingQueue Lock Atomic

Concurrency Utilities: JSR-166 Task Scheduling Framework: Executor interface replaces direct use of Thread No more direct Thread invocation Use myExecutor.execute(aRunnable); Not new Thread(aRunnable).start(); public interface Executor { void execute (Runnable command); }

Executor Framework for asynchronous execution public interface Executor { void execute (Runnable command); } public interface ExecutorService extends Executor { .. } public class Executors { //Factory methods static ExecutorService newFixedThreadPool(int poolSize); ... } Executor pool = Executors.newFixedThreadPool(5); pool.execute ( runnable ) ;

Creating Executors Factory methods in the Executors class public class Executors { static ExecutorService newSingleThreadedExecutor (); static ExecutorService newFixedThreadPool (int poolSize); static ExecutorService newCachedThreadPool (); static ScheduledExecutorService newScheduledThreadPool (); // Other methods not listed }

Thread Pool Example class WebService { public static void main(String[] args) { Executor pool = Executors.newFixedThreadPool(5); ServerSocket socket = new ServerSocket(999); for (;;) { final Socket connection = socket.accept(); Runnable task = new Runnable() { public void run() { new Handler().process ( connection ); } } pool.execute ( task ) ; } } } class Handler { void process (Socket s); }

ExecutorService for Lifecycle Support ExecutorService supports graceful and immediate shutdown public interface ExecutorService extends Executor { void shutdown (); List<Runnable> shutdownNow (); boolean isShutdown (); boolean isTerminated (); boolean awaitTermination (long timeout, TimeUnit unit); // additional methods not listed }

ScheduledExecutorService Deferred and recurring tasks Schedule execution of Callable or Runnable to run once after a fixed delay schedule () Schedule a Runnable to run periodically at a fixed rate scheduleAtFixedRate () Schedule a Runnable to run periodically with a fixed delay between executions scheduleWithFixedDelay () Submission returns a ScheduledFuture Can be used to cancel task

ScheduledExecutorService Example ScheduledExecutorService sched = Executors. newSingleThreadScheduledExecutor (); public void runTwiceAnHour(long howLong) { final Runnable rTask = new Runnable() { public void run() { /* Work to do */ } }; final ScheduledFuture<?> rTaskFuture = sched. scheduleAtFixedRate (rTask, 0, 1800, SECONDS); sched. schedule (new Runnable { public void run { rTaskFuture.cancel(true); } }, howLong, SECONDS); }

Synchronize Critical Section E.g., shared resource is an customer account. Certain methods called by multiple threads. Hold monitor lock for as short a time as possible . synchronized double getBalance() { Account acct = verify(name, password); return acct.balance; } Lock held for long time double getBalance() { synchronized (this) { Account acct = verify(name, password); return acct.balance; } } Current object is locked Equivalent to above double getBalance() { Account acct = verify(name, password); synchronized (acct) { return acct.balance}; } Better Only acct object is locked – for shorter time

Locks Java provides basic locking via synchronized Good for many situations, but some issues Single monitor per object Not possible to interrupt thread waiting for lock Not possible to time-out when waiting for a lock Block structured approach Aquiring multiple locks is complex Advanced techniques like hand-over-hand locking are not possible New Lock interface addresses these issues

Lock Interface No automatic unlocking Interface Lock { void lock (); void lockInterruptibly () throws IE ; boolean tryLock (); boolean tryLock (long t, TimeUnit u) throws IE ; //returns true if lock is aquired void unlock (); Condition newCondition () throws UnsupportedOperationException; } IE = InterruptedException

RentrantLock Simplest concrete implementation of Lock Same semantics as synchronized, but with more features Generally better performance under contention than synchronized Remember Lock is not automatically released Must use a finally block to release Multiple wait-sets supported Using Condition interface

Lock Example Lock lock = new RentrantLock(); public void accessProtectedResource() throws IllegalMonitorStateException { lock.lock(); try { // Access lock protected resource } finally { // Ensure lock is always released lock.unlock(); } }

ReadWriteLock Interface Has two locks controlling read and write access Multiple threads can aquire the read lock if no threads have a write lock Only one thread can aquire the write lock Methods to access locks rwl.readLock().lock(); rwl.writeLock().lock(); Better performance for read-mostly data access

ReadWriteLock Example ReentrantReadWriteLock rwl = new ReentrantReadWriteLock (); Lock rLock = rwl.readLock (); Lock wLock = rwl.writeLock (); ArrayList<String> data = new ArrayList<String>(); public String getData(int pos) { r.lock () ; try { return data.get (pos); } finally { r.unlock (); } } public void addData(int pos, String value) { w.lock (); try { data.add (pos, value); } finally { w.unlock (); } }

Synchronizers Co-ordinate access and control Semaphore Manages a fixed sized pool of resources CountDownLatch One or more threads wait for a set of threads to complete an action CyclicBarrier Set of threads wait until they all reach a specified point Exchanger Two threads reach a fixed point and exchange data

BlockingQueue Interface Provides thread safe way for multiple threads to manipulate collection Interface BlockingQueue<E> { void put (E o) throws IE; boolean offer (E o) throws IE; boolean offer (E o, long t, TimeUnit u) throws IE; E take () throws IE; E poll () throws IE; E poll (long t, TimeUnit u) throws IE; int drainTo (Collection<? super E> c); int drainTo (Collection<? super E> c, int max); // Other methods not listed }

BlockingQueue Implementations ArrayBlockingQueue Bounded queue, backed by an array, FIFO LinkedBlockingQueue Optionally bounded queue, backed by linked nodes, FIFO PriorityBlockingQueue Unbounded queue Uses comparator or natural ordering to determine the order of the queue

Blocking Queue Example: 1 private BlockingQueue<String> msgQueue ; public Logger ( BlockingQueue<String> mq) { msgQueue = mq; } public void run() { try { while (true) { String message = msgQueue.take (); /* Log message */ } } catch (InterruptedException ie) { } }

Blocking Queue Example: 2 private ArrayBlockingQueue messageQueue = new ArrayBlockingQueue<String>(10); Logger logger = new Logger( messageQueue ); public void run() { String someMessage; try { while (true) { /* Do some processing */ /* Blocks if no space available */ messageQueue.put(someMessage) ; } } catch (InterruptedException ie) { } }

Concurrent Collections ConcurrentMap (interface) Extends Map interface with atomic operations ConcurrentHashMap Fully concurrent retrieval Tunable concurrency for updates Constructor takes number of expected concurrent threads ConcurrentLinkedQueue Unbounded, thread safe queue, FIFO CopyOnWriteArrayList Optimised for frequent iteration, infrequent modifications

Summary New concurrency features are very powerful Lots of great features Take time to learn how to use them correctly Use them!

Classic Memory Leak in C User does the memory management void service(int n, char** names) { for (int i = 0; i < n; i++) { char* buf = (char*) malloc (strlen(names[i])); strncpy(buf, names[i], strlen(names[i])); } // memory leaked here } User is responsible for calling free() User is vulnerable to dangling pointers and double frees.

Garbage Collection Find and reclaim unreachable objects Anything not transitively reachable from the application roots: (thread stacks, static fields, registers.) Traces the heap starting at the roots Visits every live object Anything not visited is unreachable Therefore garbage Variety of approaches Compacting/non-compacting Algorithms: copying, mark-sweep, mark-compact, etc.

Generational Garbage Collection Keeps young and old objects separately In spaces called generations The weak generational hypothesis Most new objects will die young, Concentrate effort on young generation Young Generation Old Generation Object Promotion Object Allocation Track These ( Remembered Set ) Need to keep track of old-to-young pointers Eventually, have to also collect the old generation Different GC algorithms for each generation “ Use the right tool for the job”

Garbage Collection Garbage collection: Pros Increased reliability – no memory leaks, no dangling pointers Eliminates entire classes of (Pointer) bugs , no segmentation fault, no double frees Improved developer productivity True memory leaks are not possible Still possible for an object to be reachable but not used by the program Best described as unintentional object retention , Can cause OutOfMemoryError Happens less often than in C, and easier to track down Cons Pauses May require tuning – but auto-tuning is getting better!!!

Incremental Garbage Collection decreases/minimizes GC disruption GC works at the same time as the application Short stop do a little work go back

Garbage Collection Myths about garbage collection abound Myth: Allocation and garbage collection are slow In JDK 1.0 , they were slow (as was everything else) Memory management (allocation + collection) in Java is often significantly faster than in C Cost of new Object() is typically ten machine instructions It's just easier to see the collection cost because it happens all in one place Early performance advice suggested avoiding allocation Bad idea! Alternatives (like object pooling ) are often slower , more error prone , and less memory-efficient

Object Allocation (1/2) Typically, object allocation is very cheap! 10 native instructions in the fast common case C/C++ has faster allocation? No! Reclamation of new objects is very cheap too! Young GCs in generationa l systems So Do not be afraid to allocate small objects for intermediate results Generational GCs love small, short-lived objects

Object Allocation (2/2) We do not advise Needless allocation More frequent allocations will cause more frequent GCs We do advise Using short-lived immutable objects instead of long-lived mutable objects Using clearer, simpler code with more allocations instead of more obscure code with fewer allocations

Large Objects Very large objects are: Expensive to allocate (maybe not through the fast path) Expensive to initialize (zeroing) Can cause performance issues Large objects of different sizes can cause fragmentation For non-compacting or partially-compacting GCs Avoid if you can And, yes, this is not always possible or desirable

Object Pooling (1) Legacy of older VMs with terrible allocation performance Remember Generational GCs love short-lived, immutable objects… Unused objects in pools Are like a bad tax, the GC must process them Safety Reintroduce malloc/free mistakes Scalability Must allocate/de-allocate efficiently synchronized defeats the VM’s fast allocation mechanism

Object Pooling (3/3) Exceptions Objects that are expensive to allocate and/or initialize Objects that represent scarce resources Examples Threads pools Database connection pools Use existing libraries wherever possible

Memory Leaks? But, the GC is supposed to fix memory leaks! The GC will collect all unreachable objects But, it will not collect objects that are still reachable Memory leaks in garbage collected heaps Objects that are reachable but unused Unintentional object retention

Memory Leak Types “Traditional” memory leaks Heap keeps growing , and growing, and growing … OutOfMemoryError “Temporary” memory leaks Heap usage is temporarily very high , then it decreases Bursts of frequent GCs

Memory Leak Sources Objects in the wrong scope Lapsed listeners Exceptions change control flow Instances of inner classes Metadata mismanagement Use of finalizers/reference objects

Objects in the Wrong Scope (1/2) Below, names really local to doIt() It will not be reclaimed while the instance of Foo is live class Foo { private String[] names ; public void doIt (int length) { if (names == null || names.length < length) names = new String[length]; populate(names); print(names); } }

Objects in the Wrong Scope (2/2) Remember Generational GCs love short-lived objects class Foo { public void doIt(int length) { String[] names = new String[length]; populate(names); print(names); } }

Exceptions Change Control Flow (1/2) Beware Thrown exceptions can change control flow try { ImageReader reader = new ImageReader(); cancelButton.addActionListener(reader); reader.readImage(inputFile); cancelButton.removeActionListener(reader); } catch (IOException e) { // if thrown from readImage(), reader will not // be removed from cancelButton's listener set }

Exceptions Change Control Flow (2/2) Always use finally blocks ImageReader reader = new ImageReader(); cancelButton.addActionListener(reader); try { reader.readImage(inputFile); } catch (IOException e) { ... } finally { cancelButton.removeActionListener(reader); }

Metadata Mismanagement (1/2) Sometimes, we want to: Keep track of object metadata In a separate map class ImageManager { private Map<Image,File> map = new HashMap<Image,File>(); public void add(Image image, File file) { ... } public void remove(Image image) { ... } Public File get(Image image) { ... } }

Metadata Mismanagement (2/2) What happens if we forget to call remove (image)? never be removed from the map Very common source of memory leaks We want: purge the corresponding entry when the key is not reachable… That’s exactly what a WeakHashMap does purge the corresponding entry private Map<Image,File> map = new Weak HashMap<Image,File>();

Some Memory Management Myths Myth: Explicitly nulling references helps GC Rarely helpful Unless you are managing your own memory Can be harmful to correctness or performance Myth: Calling System.gc() helps GC Triggers full collection – less efficient Can be a huge performance loss Myth: Avoid object allocation Allocation in Java is lightning fast Avoidance techniques (e.g., pooling ) are very tricky to get right

Local Variable Nulling Local variable nulling i s n ot necessary The JIT can do liveness analysis void foo() { int[] array = new int[1024]; populate(array); print(array); // last use of array in method foo() array = null; // unnecessary! // array is no longer considered live by the GC ... }

Some Memory Management Myths Myth: Finalizers are Java's idea of destructors Finalizers are rarely needed and very hard to use correctly! Should only be used for native resources Adds significant work to GC , has significant performance effect Instead, use finally blocks to release resources Resource r = acquireResource(); try { useResource(r); } finally { releaseResource(r); } Note resource acquisition is outside the try block Use for file handles, database connections, etc

How “Smart Tuning” Works Provide good “ out of the box ” performance without hand tuning Determine type of machine JVM is running on configure Hotspot appropriately Server machine Larger heap, parallel garbage collector , and server compiler Client machine Same as 1.4.2 ( small heap , serial garbage collector, and client compiler

“ Smart Tuning” Dynamically adjust Java HotSpot VM software environment at runtime Adaptive Heap Sizing policy Simple tuning options based on application requirements not JVM internals

Effects of Tuning Tuned vs. Non-tuned JVM

Memory Leak Detection Tools Many tools to choose from “ Is there a memory leak”? Monitor VM’s heap usage with jconsole and jstat “ Which objects are filling up the heap?” Get a class histogram with jmap or -XX:+PrintClassHistogram and Ctrl-Break “ Why are these objects still reachable?” Get reachability analysis with jhat

Monitoring, Management, Diagnostics GUI tools: JConsole, jhat, VisualGC (NetBeans), dynamic attach Command line tools: jps, jstat, jstack, jmap, jinfo Diagnostics: CTRL-Break handler, heap dump, better OutOfMemoryError and fatal error handling, JNI crashes Tracing/logging: VM tracing and HotSpot probes, DTrace integration http://blogs.sun.com/roller/page/dannycoward/20060310

Monitoring and Management Attach on demand for jconsole : can connect to applications that did not start up with the JMX agent jstack : takes a 'photograph' of all the threads and what they are up to in their own stack frames jmap : takes a detailed 'photograph' of what's going on in memory at any one point in time jhat : forensic expert that will help you interpret the result of jmap

J2SE 5.0 Monitoring & Management

Platform Beans (MXBean's) Provides API access to number of classes loaded, threads running Thread state contention stats stack traces GC statistics memory consumption, low memory detection VM uptime, system properties, input arguments On-demand deadlock detection

Jconsole http://www.netbeans.org/kb/articles/jmx-getstart.html

NetBeans Profiler Low overhead profiling Attach to running applications CPU performance profiling Memory profiling Memory leak debugging Task based profiling Processing collected data offline http://www.netbeans.org/kb/55/profiler-tutorial.html

JDK 6 (Mustang) Features Overview

JDK 6 Component JSRs 202: Class File Update 199: Compiler API 269: Annotation Processors 260: Javadoc ™ Tag Update Ease of Development 221: JDBC ™ 4.0 223: Scripting 105: XML Digital Signature 173: Streaming API for XML XML 222: JAXB 2.0 250: Common Annotations 181: WS Metadata Web Services 224: JAX-WS 2.0 See JSR 270 at http://jcp.org

The JDK 6 Top 10 Scripting Web Services Database (JDBC 4.0, Java DB) More Desktop APIs Monitoring and Management Compiler Access Pluggable Annotations Desktop Deployment Security Quality, Compatibility, Stability

For More Information (1/2) Memory management white paper http://java.sun.com/j2se/reference/whitepapers/ Destructors, Finalizers, and Synchronization http://portal.acm.org/citation.cfm?id=604153 Finalization, Threads, and the Java Technology Memory Model http://developers.sun.com/learning/javaoneonline/2005/coreplatform/TS-3281.html Memory-retention due to finalization article http://www.devx.com/Java/Article/30192

For More Information (2/2) FindBugs http://findbugs.sourceforge.net Heap analysis tools Monitoring and Management in 6.0 http://java.sun.com/developer/technicalArticles/J2SE/monitoring/ Troubleshooting guide http://java.sun.com/javase/6/webnotes/trouble/ JConsole http://java.sun.com/developer/technicalArticles/J2SE/jconsole.html

Call for Action! Download and install JDK 5 or JDK 6 Start using the new language features ASAP

Resources http://java.sun.com/javase Java.net http://jdk.dev.java.net

Stay in Touch with Java SE http://java.sun.com/javase JDK Software Community planetjdk.org community.java.net/jdk JDK 6 http://jdk6.dev.java.net/ http://jcp.org/en/jsr/detail?id=270 JDK 7 http://jdk7.dev.java.net/ http://jcp.org/en/jsr/detail?id=277

Thank You! Carol McDonald Java Technology Architect Sun Microsystems, Inc.

Java 5 6 Generics, Concurrency, Garbage Collection, Tuning

Recommended

More Related Content

What's hot (20)

Similar to Java 5 6 Generics, Concurrency, Garbage Collection, Tuning (20)

More from Carol McDonald (20)

Recently uploaded (20)

Java 5 6 Generics, Concurrency, Garbage Collection, Tuning

Editor's Notes