Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

5 Java Performance Optimization Tricks

DZone's Guide to

5 Java Performance Optimization Tricks

Some Java performance optimization tricks include starting with minimum heap allocation, using a StringBuilder instead of the + operator, and avoiding Iterator.

Free Resource

Download our Introduction to API Performance Testing and learn why testing your API is just as important as testing your website, and how to start today.

Optimizing your Java code requires a proper analysis of how it works. There are several factors that affect performance optimization, like garbage collection, OS settings, and virtual machinery.

1. Start With Minimum Heap Allocation

I recommend that you start with minimum memory allocation. Then, you can gradually increase it depending upon the program requirements. You can instruct the JVM to dump the heap on an OutOfMemoryError exception by adding the following argument to the JVM:

-XX:+HeapDumpOnOutOfMemoryError

Proper utilization of the available memory is a great way to optimize for speed.

A heap size of 1GB to 7GB is sufficient to get started. It should depend on an old generation to new generation-object ratio.

2. Make Use of Java Performance Tools

There are several Java performance tools like VisualVM, YourKit, Java Mission Control, etc., which you can use to keep a track of your application performance.

The NetBeans profiler is also a great option. NetBeans IDE supports the development of all Java application types  Java SE (including JavaFX), Java ME, web, EJB, and mobile applications — out of the box.

3. Use a StringBuilder Rather Than the + Operator

The below code could come handy in place of two separate codes of StringBuilder:

StringBuilder x = new StringBuilder("a");
x.append(args.length);
x.append("b");
if (args.length == 1);
x.append(args[0]);

This makes any amendment easy without putting extra pressure on the GC.

4. Avoid Using Iterator

If we use a code like:

for (String value: strings) {
 // Do something useful here
}

Then every time we run this code, a new iterator instance will be created that will consume much of our memory.

Instead, the following code is recommended:

int size = strings.size();
for (int i = 0; i < size; i++) {
 String value: strings.get(i);
 // Do something useful here
}

…or, if your list doesn’t really change, you might even operate on an array version of it:

for (String value: stringArray) {
 // Do something useful here
}

Writing index-based iterations is extremely useful.

5. Have Better Concurrency Control

Concurrency is the ability to run multiple programs in parallel to each other.

For tackling multi-request web flows, it is recommended to use optimistic locking with detached entities or an EXTENDEDPersistence Context.

Moreover, it is essential to understand the inner workings of the relational database management system (RDBMS) and the data access frameworks in order to improve the performance of the data access layer.

Find scaling and performance issues before your customers do with our Introduction to High-Capacity Load Testing guide.

Topics:
performance ,java performance ,optimization ,tutorial

Opinions expressed by DZone contributors are their own.

THE DZONE NEWSLETTER

Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.

X

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}