JProfiler Get rid of your performance problems and memory leaks! Modern Garbage Collection Tuning Java Performance Training Courses COURSES AVAILABLE NOW. We can provide training courses to handle all your Java performance needs Java Performance Tuning, 2nd ed The classic and most comprehensive book on tuning Java Java Performance Tuning Newsletter Your source of Java performance news. Subscribe now! Enter email: Training online Threading Essentials course JProfiler Get rid of your performance problems and memory leaks!

Java performance tuning tips relevent when using synchronization.

Synchronization tips referred to by this page are: about the use of the synchronization keyword; alternatives to using synchronization; overheads from using synchronization; contention costs of using synchronization.

Not included here are: tips about synchronizing data across distributed systems, such as synchronizing caches; nor tips about using asynchronous communications or I/O.

The following pages have their detailed tips extracted below

• Comparing the performance of LinkedLists and ArrayLists (and Vectors)
• My article on basic optimizations for queries on collections
• Article about optimizing queries on Maps.
• For years, Jonathan Hardwick's old but classic site was the only coherent Java performance tuning site on the web
• "Cutting Edge Java Game Programming"
• Glen McCluskey's paper with 30 tuning tips, now free.
• Performance tuning part of a white paper about Java on Solaris 2.6.
• Patrick Killelea's Java performance tips.
• HP Java tuning site, including optimizing Java and optimizing HPUX for Java
• J2EE Application server performance
• Performance tuning report in German
• A different HP tip page on optimizing Java performance, from the "HP-UX Programmer's Guide for Java"
• Paper detailing the "Best Practices for Developing High Performance Web and Enterprise Applications" using IBM's WebSphere
• When synchronization is required
• Reducing thread contention
• The hprof profiler
• Thread programming
• An assortment of tips
• Various performance tips
• Avoiding synchronization deadlocks
• Techniques to avoid deadlocks
• Deadlocks
• Servlet performance tips
• JSP performance tips
• Chapter 3 of "High Performance Java Computing : Multi-Threaded and Networked Programming", "Race Conditions and Mutual Exclusion"
• Chapter 4 of "High Performance Java Computing : Multi-Threaded and Networked Programming", "Monitors"
• Benchmarking JMS
• Multithreading and read-write locks
• Multithreading and read-write locks, part 2
• MIDP GUI programming
• Both Java specific and Java on OS/390 tips.
• Javaworld tip article, detailing a buffered RandomAccessFile class.
• Nice article on understanding bytecodes by Peter Haggar, Added 2000-10-23, Author of "Practical Java"
• Chapter 1 of "Enterprise Java Performance", "Performance in General"
• Tuning the IBM JVM and Linux
• Peter Haggar's Practical Java Programming Language Guide.
• Basic animation tutorial
• Sun community chat session: Tuning the Java Runtime for "Big Iron"
• Basic article on performance tuning techniques.
• Chapter 8, "Algorithms and data structures" of "Java Platform Performance: Strategies and Tactics
• Various tips.
• Sun presentation on J2SE performance strategies
• Introductory level article on threading applets
• IBM's list of Java performance tuning tips (same page, two URLs).
• Double-if on multi-CPU
• Some IBM Java performance tips
• Research paper on high performance Java.
• Runtime

The following detailed tips have been extracted from the raw tips page

http://www.onjava.com/pub/a/onjava/2001/05/30/optimization.html
Comparing the performance of LinkedLists and ArrayLists (and Vectors) (Page last updated May 2001, Added 2001-06-18, Author Jack Shirazi, Publisher OnJava). Tips:

• ArrayList is faster than Vector except when there is no lock acquisition required in HotSpot JVMs (when they have about the same performance).
• Synchronized wrappers (obtained from Collections.synchronizedList(List)) add a level of indirection which can have a high performance cost.
• Only List and Map have efficient thread-safe implementations: the Vector and Hashtable classes respectively.

http://java.oreilly.com/news/javaperf_0900.html
My article on basic optimizations for queries on collections (Page last updated September 2000, Added 2000-10-23, Author Jack Shirazi, Publisher O'Reilly). Tips:

• Avoid synchronization where possible.

http://www.javaworld.com/javaworld/jw-11-2000/jw-1117-optimize.html
Article about optimizing queries on Maps. (Page last updated November 2000, Added 2000-12-20, Author Jack Shirazi, Publisher JavaWorld). Tips:

• Avoid using synchronization in read-only or single-threaded queries.

http://www.cs.cmu.edu/~jch/java/optimization.html
For years, Jonathan Hardwick's old but classic site was the only coherent Java performance tuning site on the web. He built it while doing his PhD. It wasn't updated beyond March 1998, when he moved to Microsoft, but most tips are still useful and valid. The URL is for the top page, there are another eight pages. Thanks Jonathan. (Page last updated March 1998, Added 2000-10-23, Author Jonathan Hardwick, Publisher Hardwick). Tips:

• Avoid synchronized methods if you can.
• Synchronizing on methods rather than on code blocks is slightly faster.

http://library.cs.tuiasi.ro/programming/java/cutting_edge_java_game_programming/ewtoc.html
"Cutting Edge Java Game Programming". Oldish but still useful intro book to games programming using Java. (Page last updated 1996, Added 2001-06-18, Author Neil Bartlett, Steve Simkin , Publisher Coriolis). Tips:

• To optimize speed: avoid synchronized methods; use buffered I/O; reuse objects; avoid unnecessary screen painting.

http://www.glenmccl.com/jperf/
Glen McCluskey's paper with 30 tuning tips, now free. (Page last updated October 1999, Added 2000-10-23, Author Glen McCluskey, Publisher McCluskey). Tips:

• Synchronized methods are slower than the identical non-synchronized one.
• Consider using non-synchronized classes and synchronized-wrappers.

http://www.sun.com/solaris/java/wp-java/6.html
Performance tuning part of a white paper about Java on Solaris 2.6. (Page last updated 2000, Added 2000-10-23, Author ?, Publisher Sun). Tips:

• FastVector is faster than Vector by making the elementData field public, thus avoiding (synchronized) calls to elementAt().
• Minimize synchronization.
• Polling is only acceptable when waiting for outside events and should be performed in a "side" thread. Use wait/notify instead.

http://www.patrick.net/jpt/index.html
Patrick Killelea's Java performance tips. (Page last updated 1999, Added 2000-10-23, Author Patrick Killelea, Publisher Killelea). Tips:

• Use threads. Prioritize threads. Use notify instead of notifyAll. Use synchronization sparingly.
• Keep synchronized methods out of loops if you possibly can.
• Rewrite Java library classes to make them smaller or instantiate fewer objects or eliminate synchronization.

http://www.devresource.hp.com/JavaATC/JavaPerfTune/index.html
HP Java tuning site, including optimizing Java and optimizing HPUX for Java. This is the top page, but several useful pages lie off it (tips extracted for inclusion below). Includes a nice "procedure" list for tuning apps, and some useful forms for what you should record while tuning. (Page last updated 2000, Added 2000-10-23, Author ?, Publisher HP). Tips:

• Be certain that the application's CPU usage is a factor limiting performance: often, highly contended locks and garbage collections that are too frequent will make the system look busy, but little work is done by the application.

http://www.sys-con.com/java/article.cfm?id=671
J2EE Application server performance (Page last updated April 2001, Added 2001-04-20, Author Misha Davidson, Publisher Java Developers Journal). Tips:

• Minimize the use of synchronization.
• Avoid using the SingleThreadModel interface for servlets: write thread-safe code instead.

http://www.bastie.de/resource/res/mjp.pdf and http://www.bastie.de/java/mjperformance/contents.html
Performance tuning report in German. Thanks to Peter Kofler for extracting the tips. (Page last updated November 2001, Added 2001-07-20, Author Sebastian Ritter, Publisher Ritter). Tips:

• use Arraylist instead of Vector
• use methods in order: static > final > instance > interface > synchronized
• avoid synchronization
• use synchronized blocks instead of synchronized methods

http://www.unixsolutions.hp.com/products/java/perf.html
A different HP tip page on optimizing Java performance, from the "HP-UX Programmer's Guide for Java". Gives info on HP system performance monitoring too (Page last updated ?, Added 2000-10-23, Author ?, Publisher HP). Tips:

• Minimize contention for shared resources.

http://www-4.ibm.com/software/webservers/appserv/ws_bestpractices.pdf
Paper detailing the "Best Practices for Developing High Performance Web and Enterprise Applications" using IBM's WebSphere. All the tips are generally applicable to servlet/EJB development, as well as other types of server development. (Page last updated September 2000, Added 2001-01-19, Author Harvey W. Gunther, Publisher IBM). Tips:

• Minimize synchronization in Servlets to avoid multiple execution threads becoming effectively single-threaded.

http://www-106.ibm.com/developerworks/java/library/j-threads1.html
When synchronization is required (Page last updated July 2001, Added 2001-07-20, Author Brian Goetz, Publisher IBM). Tips:

• synchronization means mutual exclusion (if the same monitor is used), atomicity of the synchronized block (again with respect to other threads using the same monitor) and synchronization of thread memory to main memory.
• Because synchronization synchronizes thread memory with main memory, there is a cost to synchronization beyond simply acquiring a lock.
• Too little synchronization can lead to corrupt data; too much can lead to reduced performance and deadlock.
• The costs of synchronization vary with JVMs, with more recent JVMs being more efficient.
• The costs of synchronization differs depending on whether or not threads are actually contending for locks (more expensive, slower), or for uncontended synchronization where the thread is basically acting in single-threaded mode (cheaper, faster).
• You need to synchronize or make volatile variables holding data that will be shared between threads.
• Composite operations may need synchronizing to make them atomic even if each individual operation is already synchronized.

http://www-106.ibm.com/developerworks/java/library/j-threads2.html
Reducing thread contention (Page last updated September 2001, Added 2001-10-22, Author Brian Goetz, Publisher IBM). Tips:

• Make synchronized blocks as short as possible.
• Spread synchronizations over more than one lock.
• [Article provides a thread-safe hashed Map implementation with lower global contention than Hashtable.]
• If you will be acquiring and releasing the same lock many times (such as in a loop), acquire the lock before the loop: it is faster to acquire a lock that you already hold than one that nobody holds.

http://www.javaworld.com/javaworld/jw-12-2001/jw-1207-hprof.html
The hprof profiler (Page last updated December 2001, Added 2001-12-26, Author Bill Pierce, Publisher JavaWorld). Tips:

• hprof can be used to profile object allocation (heap option), method bottlnecks (cpu option) and thread contention (monitor option).

http://www.devx.com/upload/free/Features/Javapro/2002/02feb02/kr0202/kr0202-1.asp
Thread programming (Page last updated January 2002, Added 2002-01-25, Author Karthik Rangaraju, Publisher DevX). Tips:

• Use Djikstra semaphores (synchronized acquire()/release()) to control access to a finite pool of resources.
• Conditional events provide a more sophisticated version of the wait()/notify() mechanism which avoids some potential problems of that mechanism.

http://jsl.jcon.org/javaperformance.html
An assortment of tips (Page last updated 2000, Added 2000-10-23, Author Curt Smith, Publisher Smith). Tips:

• Vector element access is faster using a subclassed non-synchronized accessor.
• Minimizing synchronization may take work, but can pay off well.
• Eliminate calls to synchronized methods (but be careful of being overly ambitious in this).
• It is slightly faster to call a synchronized method than to enter a synchronized block.
• Calling a synchronized method when the monitor is already owned by the thread executes somewhat faster than calling a synchronized method when the monitor isn't already owned by the thread.

http://www.nandighosha.org/forum/topic.asp?TOPIC_ID=185&FORUM_ID=10&CAT_ID=2&Topic_Title=Java+performance+tuning+tips&Forum_Title=Java+%2D+Tips+Of+The+Day
Various performance tips (Page last updated May 2001, Added 2001-06-18, Author Asha Balasubramanyan, Publisher Nandighosha). Tips:

• Use ArrayList for non-synchronized Vectors.

http://www.javaworld.com/javaworld/jw-10-2001/jw-1012-deadlock.html
Avoiding synchronization deadlocks (Page last updated October 2001, Added 2001-10-22, Author Brain Goetz, Publisher JavaWorld). Tips:

• Deadlocks are difficult to identify from code analysis, and can occur unexpectedly.
• Always acquire locks in the same order to avoid one common cause of deadlocking. If you can guarantee that all locks will always be acquired in a consistent order, then your program will not deadlock.
• Try to avoid acquiring more than one lock at a time (though this is usually impractical).
• Keep synchronized blocks of code as short as possible.

http://www.sys-con.com/java/article.cfm?id=1133
Techniques to avoid deadlocks (Page last updated September 2001, Added 2001-10-22, Author Mark Dykstra, Publisher Java Developers Journal). Tips:

• Potential deadlocks can be caused by coding styles.
• Always acquire a set of locks in the same set order.
• Don't hold a lock and wait for an event.
• Specify which thread should have access to data at any time.
• Ensure that both access and update to the same variable is synchronized on the same monitor.

http://www.javaspecialists.co.za/archive/Issue001.html
Deadlocks (Page last updated November 2000, Added 2002-04-26, Author Heinz M. Kabutz, Publisher Kabutz). Tips:

• Use CTRL+BREAK to get a thread dump when a deadlock occurs, to find where the deadlock is.
• Use SwingUtlities.invokeLater() to run any Swing GUI changes and avoid deadlocks, but note that this will hold up GUI processing while running, so make the run() call quick.
• Use SwingUtilities.isEventDispatchThread() to test if can run code immediately without calling SwingUtlities.invokeLater().

http://www.precisejava.com/javaperf/j2ee/Servlets.htm
Servlet performance tips (Page last updated November 2001, Added 2001-12-26, Authors Ravi Kalidindi and Rohini Datla, Publisher PreciseJava). Tips:

• Minimize the synchronized block in the service method.

http://www.precisejava.com/javaperf/j2ee/JSP.htm
JSP performance tips (Page last updated November 2001, Added 2001-12-26, Authors Ravi Kalidindi and Rohini Datla, Publisher PreciseJava). Tips:

• Minimize the synchronized block in the service method.

http://developer.java.sun.com/developer/Books/performance2/chap3.pdf
Chapter 3 of "High Performance Java Computing : Multi-Threaded and Networked Programming", "Race Conditions and Mutual Exclusion" (Page last updated January 2001, Added 2001-02-21, Authors George Thiruvathukal, Thomas Christopher, Publisher Sun). Tips:

• INVALID: NOTE THE TIP "volatile primitive datatypes cannot be cached, and have a write-through update policy allowing atomic read-writes, i.e. x++ is an atomic operation if x is volatile." HAS BEEN SHOWN TO BE INVALID.
• Use resource enumeration (acquire resources in a set order) to avoid deadlocks.

http://developer.java.sun.com/developer/Books/performance2/chap4.pdf
Chapter 4 of "High Performance Java Computing : Multi-Threaded and Networked Programming", "Monitors" (Page last updated January 2001, Added 2001-02-21, Authors George Thiruvathukal, Thomas Christopher, Publisher Sun). Tips:

• Java monitors are not necessarily the most efficient synchronization mechanism, especially if transferring the lock can lead to a race condition [chapter discusses a more complete Monitor class].
• volatile fields can be slower than non-volatile fields, because the system is forced to store to memory rather than use registers. But they may useful to avoid concurrency problems.
• [The chapter discusses various policies for synchronizing threads trying to read from or write to shared resources, which provide different scheduling policies: one thread at a time; readers-preferred (readers have priority); writers-preferred (writers have priority); alternating readers-writers (alternates between a single writer and a batch of readers); take-a-number (first-come, first-served)].

http://www.sys-con.com/java/article.cfm?id=639
Benchmarking JMS (Page last updated March 2001, Added 2001-03-21, Author Dave Chappell, Bill Wood, Publisher Java Developers Journal). Tips:

• Scaling middleware exposes a number of issues such as threading contention, network bottlenecks, message persistence issues, memory leaks, and overuse of object allocations.

http://softwaredev.earthweb.com/java/article/0,,12082_951051,00.html
Multithreading and read-write locks (Page last updated January 2002, Added 2002-01-25, Author Nasir Khan, Publisher EarthWeb). Tips:

• When a thread passes through a synchronized block, all variables throughout the thread are synchronized with main memory, not just the set of variables in the current method.

http://softwaredev.earthweb.com/java/article/0,,12082_951051,00.html
Multithreading and read-write locks, part 2 (Page last updated January 2002, Added 2002-01-25, Author Nasir Khan, Publisher EarthWeb). Tips:

• Operations on primitive variables are atomic (except double and long), but a combination of two atomic operations is not atomic, and it is easy to make a mistake about this.
• Volatile variables are always synchronized with the main memory copy.

http://www.onjava.com/pub/a/onjava/excerpt/wirelessjava_ch5/index3.html
MIDP GUI programming (Page last updated March 2002, Added 2002-03-25, Author Qusay Mahmoud, Publisher OnJava). Tips:

• To avoid deadlock paint() should not synchronize on any object already locked when serviceRepaints() is called.

http://www-1.ibm.com/servers/eserver/zseries/software/java/perform.html
Both Java specific and Java on OS/390 tips. (Page last updated 2000, Added 2000-10-23, Author ?, Publisher IBM). Tips:

• Use synchronized methods only when necessary

http://www.javaworld.com/javatips/jw-javatip26.html
Javaworld tip article, detailing a buffered RandomAccessFile class. (Page last updated 1998?, Added 2000-10-23, Author Nick Zhang). Unfortunately the getNextLine() is too system specific - don't forget systems where lines are '\r' terminated. Tips:

• Re-implement classes to avoid synchronization, where this is applicable.

http://www.developer.ibm.com/library/articles/programmer/haggar_bytecode.html
Nice article on understanding bytecodes by Peter Haggar, Added 2000-10-23, Author of "Practical Java". Explains why a synchronized method is faster than a functionally identical synchronized block. (Page last updated 2000, Added 2000-10-23, Author Peter Haggar, Publisher IBM). Tips:

• Don't synchronize code unless synchronization is required.
• Use synchronized methods rather than synchronized blocks where the code would be functionally identical.

http://developer.java.sun.com/developer/Books/programming/performance/eperformance/eJavaCh01.pdf
Chapter 1 of "Enterprise Java Performance", "Performance in General". Includes the infamous sentences "It is likely that the code will not meet the performance requirements the very first time it runs. Even if it does, it may be worthwhile to look for some ways to improve it." NO NO NO! If the code meets the performance requirements, DON'T CHANGE IT. Next time guys, ask me to review your book before you publish. (Page last updated 2000, Added 2000-10-23, Authors Steven Halter & Steven Munroe, Publisher Sun). Tips:

• Avoid monopolizing shared resources.

http://www-106.ibm.com/developerworks/ibm/library/i-tuning/?open
Tuning the IBM JVM and Linux (Page last updated May 2001, Added 2001-10-22, Authors Duc Vianney and James Phelan, Publisher IBM). Tips:

• Limit the use of synchronized methods.

http://www.awlonline.com/product/0,2627,0201616467,00.html
Peter Haggar's Practical Java Programming Language Guide. (Page last updated 2000, Added 2001-01-19, Author Peter Haggar, Publisher Addison-Wesley). Tips:

• Minimize synchronization.

http://www.cs.tcd.ie/courses/baict/bacs/sf/Animation/
Basic animation tutorial (Page last updated ?, Added 2000-12-20, Author Dave ?, Publisher ?). Tips:

• Use synchronization to synchronize methods in the two threads.

http://developer.java.sun.com/developer/community/chat/JavaLive/2001/jl0327.html
Sun community chat session: Tuning the Java Runtime for "Big Iron" (Page last updated March 2001, Added 2001-04-20, Author Edward Ort, Publisher Sun). Tips:

• Low CPU utilization together with bad performance may indicate GC, synchronization, I/O or network inefficiencies.

http://www.java-pro.com/upload/free/features/javapro/2001/01jan01/tm0101/tm0101.asp
Basic article on performance tuning techniques. (Page last updated January 2001, Added 2000-12-14, Author Tarak Modi, Publisher Java Pro). Tips:

• Unsynchronized methods are faster than synchronized ones.

http://java.sun.com/docs/books/performance/1st_edition/html/JPAlgorithms.fm.html
Chapter 8, "Algorithms and data structures" of "Java Platform Performance: Strategies and Tactics." (Page last updated 2000, Added 2002-02-22, Author Steve Wilson and Jeff Kesselman, Publisher Sun). Tips:

• Programs pay the costs associated with thread synchronization even when they're used in a single-threaded environment.

http://www.protomatter.com/nate/java-optimization/
Various tips. (Page last updated 1999?, Added 2000-10-23, Author Nate Sammons, Publisher Sammons). Tips:

• Use non-synchronized Vector, Hashtable, etc. where possible.

http://developer.java.sun.com/developer/onlineTraining/webcasts/chicago/pdf/j2se.pdf
Sun presentation on J2SE performance strategies (originally accessed from Reginald Hutcherson's page) (Page last updated May 2001, Added 2001-06-18, Author Reginald Hutcherson, Publisher Sun). Tips:

• Reduce multithreading overheads by targeting the granularity of locks, and managing synchronization correctly.
• Method synchronization is slightly faster than block synchronization (and produces smaller bytecode).

http://developer.java.sun.com/developer/technicalArticles/Threads/applet/index.html
Introductory level article on threading applets (Page last updated March 2001, Added 2001-03-21, Author Monica Pawlan, Publisher Sun). Tips:

• The volatile modifier requests the Java VM to always access the shared copy of the variable so the its most current value is always read. If two or more threads access a member variable, AND one or more threads might change that variable's value, AND ALL of the threads do not use synchronization (methods or blocks) to read and/or write the value, then that member variable must be declared volatile to ensure all threads see the changed value.

http://www-4.ibm.com/software/os/warp/performance/javatip.htm
IBM's list of Java performance tuning tips (same page, two URLs). (Page last updated 2000, Added 2000-10-23, Author ?, Publisher IBM). Tips:

• Don't overuse synchronized methods.

http://www-106.ibm.com/developerworks/java/library/j-jtctips/j-jtc0219a.html
Double-if on multi-CPU (Page last updated February 2002, Added 2002-03-25, Author Phil Vickers, Publisher IBM). Tips:

• Double-if logic fails on multiple CPU machines. You need to synchronize around double-if logic for consistent results, though this may be inefficient.

http://www.as400.ibm.com/developer/java/faq/perffaq.html
Some IBM Java performance tips. Although intended for AS/400 Java, many tips are generally applicable (Page last updated ?, Added 2000-10-23, Author ?, Publisher IBM). Tips:

• Minimize the use of synchronized methods.
• Use faster accesses. Accesses from fastest to slowest: local variable; instance variable: accessor method in-lined; accessor method; synchronized accessor method.

http://www.ibm.com/java/education/javahipr/javahipr1.html
Research paper on high performance Java. (Page last updated 1999, Added 2000-10-23, Author Sandeep K. Singhal, Publisher IBM). Tips:

• Avoid synchronization where possible.

http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-traps.html
Runtime.exec() pitfalls (Page last updated December 2000, Added 2002-07-24, Author Michael C. Daconta, Publisher JavaWorld). Tips:

• Runtime.waitFor blocks until the spawned process terminates.