Java Performance Tuning: 10 Proven Techniques for Maximizing Java Speed

One of the most popular programming languages with a wide variety of uses, it has many helpful qualities and supports numerous things you can create with Java, ranging from enterprise software to mobile applications. However, it has often been critiqued for its performance.

How do you address Java performance problems within your Java development services? Here, we’ll explore various techniques for optimizing the performance of your applications, a process known as Java performance tuning.

#1 Profiling for Performance Degradation

When optimizing your code, you should try to find the biggest performance problems and fix them first. But sometimes, it is not obvious which part is causing the issues. In these cases, it is best to use a profiler.

A profiler is a tool used to identify performance issues such as bottlenecks, memory leaks, and other areas of inefficiency in the code.

Java profilers work by collecting data about various aspects of a running Java application, such as the time it takes to execute methods, memory allocations, thread behavior, and CPU usage. This data is then analyzed to provide detailed information about the application’s performance characteristics.

Some commonly used Java profilers are VisualVM, JProfiler, and YourKit. Intellij also provides a suite of tools for application profiling.

#2 Performance Testing

Performance testing is the process of subjecting your application to realistic or extreme situations and analyzing how it performs. Some popular options are Apache JMeter, Gatling, and BlazeMeter.

Profiling and performance testing are two different things. Profiling is similar to looking at a car up close and examining its different parts. On the other hand, performance testing is like taking a toy car for a ride and seeing how it performs in different situations. Once you have conducted performance tests and identified some errors, you can use a profiling tool to find the underlying cause of those issues.

#3 Load Testing

Load testing is a type of performance testing that involves simulating realistic loads on a system or application to measure its behavior under normal and peak load conditions.

Imagine you have a website and want to know how many people can use it at the same time without it breaking or becoming too slow. To do this, we use special tools that simulate a large number of users using the website or application all at once.

Some popular load-testing applications are Apache JMeter, WebLoad, LoadUI, LoadRunner, NeoLoad, LoadNinja, and so on.

#4 Use Prepared Statement

In Java, Statement is used to execute SQL queries. However, the Statement class has a few flaws. Let’s look at the example below.

Connection db_con = DriverManager.getConnection();
Statement st = db_con.createStatement();

String username = "USER INPUT";
String query = "SELECT user FROM users WHERE username = '" + username + "'";
ResultSet result = st.executeQuery(query);

If the user were to pass ‘ OR 1=1– the resulting query would become:

SELECT user FROM users WHERE username = '' OR 1=1 -- '

This would cause the query to return all records in the users’ table since the OR 1=1 condition is always true. The double dash — at the end is a comment in SQL, which causes the rest of the original query to be ignored. This type of attack is called SQL Injection.

Statements are vulnerable to SQL injections, and therefore, you should use PreparedStatement.

PreparedStatements are pre-compiled SQL statements. Being pre-compiled, they are much more performant than Statements which are compiled for every new query. Unlike Statements, they can be reused multiple times with different parameters. You can put “?” in the query which can be replaced by a desired parameter.

#5 Optimize Strings

As we know, strings in Java are objects. However, you might have noticed that strings behave slightly differently from ordinary objects. Here’s an example to demonstrate.

When we create two objects, they are assigned different memory locations, and an equality comparison returns false.

Object obj1 = new Object();
Object obj2 = new Object();
System.out.print(obj1 == obj2);  // false

But for strings, equality comparison on two similar strings yields true. In fact, this occurs only when we create strings through the literal syntax. If you create strings using the constructor, equality comparison does yield false.

String str1 = "java";
String str2 = "java";
System.out.print(str1 == str2);  // true

String obj1 = new String("java");
String obj2 = new String("java");
System.out.print(str1 == str2);  // false

This occurs because when strings are created using the literal syntax, they are stored in a string pool, which is part of the heap memory. Whenever a new string is created, Java checks whether similar strings exist, and if it does, it returns the reference to the original string object instead of creating a new one.

Another thing to note is that strings are immutable, and hence string methods return new strings instead of modifying the old ones. So, every time you modify a string, you are creating new strings, each of which checks the string pool for duplicates. This is not optimized.

StringBuilder and StringBuffer

To address these issues, Java provides the StringBuilder class, which is just a mutable sequence of characters. Use StringBuilder when you are modifying strings frequently.

The StringBuffer works very similarly to StringBuilder, except that it can be synchronized across multiple threads.

Apache Commons StringUtils

The StringUtils class provides some additional methods to deal with strings. Some of them are more performant than the native string methods. For example, the StringUtils.replace() is faster than String.replace(). Additionally, most methods are null safe, meaning they do not throw NullPointerException if the string is null.

Regular Expressions

Use regular expressions when matching for a pattern because they are much more efficient than any iterative pattern-matching techniques.

#6 Optimize Java Virtual Machine Garbage Collection Process

The JVM is responsible for managing the runtime environment of Java applications, including memory management, thread management, and garbage collection process. The default settings of the JVM are optimized for a broad range of applications and hardware configurations, but they may not be optimal for specific applications and environments.

Choosing the Right Garbage Collector

The default collector for JDK 9 and higher is the G1 collector, which is designed to scale with the size of the heap memory. ZGC is built for applications with huge heaps that require low throughput.

-XX:+UseG1GC – to use G1 collector

-XX:+UnlockExperimentalVMOptions -XX:+UseZGC – to use ZGC

Tuning Size of Heap Memory

The heap is the area of memory where objects are allocated. By adjusting the size of the heap memory, you can optimize memory usage and prevent issues such as OutOfMemoryError or excessive garbage collection.

To set the heap size, you can use the -Xmx and -Xms flags.

The -Xmx flag limits the maximum heap size JVM can allocate. For example, passing -Xmx2g will limit the maximum heap size to 2 gigabytes.

The -Xms flag sets the initial heap size. For example, if you set -Xms256m, the JVM will start with a heap size of 256 megabytes.

Tuning Some Compiler Options

There are lots of flags that can be used to customize the behavior of the Java Virtual Machine. Here are some of the important ones:

-XX:MaxGCPauseMillis: This option specifies the maximum amount of time that the garbage collector is allowed to pause the application.

-XX:UseAdaptiveSizePolicy: This option tells the JVM to dynamically adjust the size of the young and tenured generations based on the application’s memory usage.

#7 Use Recursion

Recursion is a great way of solving complex problems where the iterative solution might not be obvious. However, you should use recursion sparingly if memory usage is critical (e.g. embedded systems).

To understand why, let us see how memory is allocated during a method call.

When a function is called, the JVM allocates a stack frame for the function on the call stack, which contains the function’s local variables and method arguments. If the function calls another function, a new stack frame is allocated for that function and added to the top of the call stack.

In the iterative approach, the local variables are created once. However, in the case of the recursive approach, each stack frame has its own set of local variables, which might take more space than required.

Hence, if you are working in an environment where memory is limited, it is best to avoid recursion or add some kind of checks that prevent recursion after a certain limit.

#8 Use Of Primitives And Wrappers

Primitives are more efficient than their wrapper classes. This is expected because primitives only take up a fixed amount of space whereas wrapper classes have their own methods and local variables that take up some extra space.

For similar reasons, try to avoid BigInteger or BigDecimal classes, if precision is not a concern.

However, there are times when you should use wrapper classes. For example, when using collections like Lists and Maps, the Java Virtual Machine converts the primitives into their respective wrapper classes (autoboxing). In these cases, the use of primitives can lead to performance hits.

When creating wrapper class instances, try using the valueOf static method instead of the constructor as it deprecated since Java 9.

#9 Use the Latest JDK Version

Unless your application relies on some features of older JDKs that have limited backward compatibility with the newer ones, there is not much reason to not use the latest JDKs. Every new version comes with bug fixes, performance enhancements, and security patches. Newer versions might include features that improve your code in many ways.

#10 Premature Optimization

Premature optimization refers to the practice of optimizing code, including the usage of Java frameworks before it is necessary. There is no added benefit to optimizing your code or selecting specific Java frameworks beforehand. It’s better to focus on making your code work first and then worry about making it faster or selecting the optimal Java frameworks.

Focusing on optimization too early in the development process can divert valuable time and resources from more critical tasks, such as functionality, reliability, and maintainability.

Instead of optimizing every piece of code, optimize the critical components or bottlenecks that have the most impact on performance. This approach allows you to achieve better results quickly.

Conclusion

In this Java performance tuning guide, we’ve explored methods for enhancing the speed of your applications. This is crucial whether you’re working in-house or outsourcing Java development. By adhering to these best practices and understanding the exact performance capabilities, you can release higher-quality products regardless of your development approach. If you’re looking to hire Java developers, these insights can also help ensure you choose candidates who are well-versed in these optimization techniques.

FAQs

How can Java developers efficiently manage memory usage to minimize the impact on application performance?

In order to manage memory, Java developers need to use the right garbage collector. The G1 Garbage Collector is the most versatile. Second, you should dispose of unused objects by setting their reference to null.