Java Application Performance Monitoring: Eight Tips and Best Practices

By Staff Contributor on April 3, 2023

Java is one of the most popular programming languages. It’s powerful yet approachable, allowing both new and experienced developers to work with it in an efficient manner. And thanks to the Java Virtual Machine (JVM), Java is deployable regardless of operating system and architecture, which lowers the cost of adoption and makes it a versatile language IT pros can use in various environments and scenarios.

In addition to the ease of use and versatility of the language, JVM is a cult favorite because of its performance. However, this doesn’t mean Java applications don’t suffer from performance problems. To avoid these, you should use a proactive approach and adopt application performance monitoring (APM).

This post is all about Java APM. We’ll start with the fundamentals, covering what APM is and why it’s valuable. Afterward, we’ll go deeper, sharing tips and best practices to help you get the most out of your Java APM strategy.

Java APM: The What and Why

Improving server-side performance is a great way to improve user experience, which can drive additional revenue for your business.

This is true for any kind of software, but it’s particularly important for web applications, since the competition is always a few clicks away.

But how can you improve performance? It all starts with the code itself. Adopting techniques such as code reviews and/or pair programming can reduce the likelihood of code with poor performance reaching production and can help you catch errors before code is launched to production.

However, these solutions can only go so far. At some point, you’ll need to leverage automation and tools capable of helping you track the behavior of your software in production in real time. These tools allow you to detect issues as early as possible and fix them before your users even notice them.

This is what APM is all about.

Four General APM Best Practices

Let’s start with APM tips and best practices not specific to Java.

1: Identify and Fix Performance Bottlenecks Early With Code Profiling

Performance issues and other problems in the code are typically cheaper to fix the sooner you detect them.

By making use of automatic profiling software, you can identify and fix performance problems in the codebase.

As we said in the previous section, the sooner you find out about issues, the easier it is to fix them. But to detect performance issues, you must first have a clear understanding of what normal performance looks like.

In other words, you need baselines. One of the first steps in your APM strategy should be to benchmark your application so you know where you currently stand. Based on this, you can start putting alerts in place. You can even use this baseline to test changes in your staging environment to ensure the push to production is smooth and painless.

With automatic profiling, thresholds defined, and alerts set, you’ll be able to detect deviations from your baselines. When you find issues, you’ll be able to remove them as quickly as possible. To make the whole process more foolproof, you can add the checks to your continuous integration/continuous delivery (CI/CD) pipeline.

2: Leverage Transaction Tracing

Long gone are the days in which the monolithic application reigned unquestioned. Though of course monoliths still exist, distributed systems are here to stay.

Understanding the performance of distributed services can often be a challenge. In this scenario, distributed transaction tracing is essential.

This type of tracing allows you to track a single request on its journey through multiple services. Using appropriate tools, you can collect data as a request traverses through your system. You can drill down on specific data points to learn more.

By doing so, you can understand how each component contributes to the overall performance of a request—and the experience provided to the user—and use what you learn for more informed decision-making.

3: Centralize Your Monitoring in a Unified Dashboard

Visualization is a key component of any monitoring strategy. Using a centralized dashboard to visualize all performance-related activity, developers can more easily detect performance issues. A great APM tool should allow you to integrate custom metrics alongside system metrics and pull in data from multiple systems.

Perhaps most importantly, your APM tool should allow you to create custom dashboards. This is a key feature, since not every predefined dashboard will be equally valuable for your scenarios. Your APM tool of choice should provide you with the necessary graphic tools so you can pick the most important metrics as you build your own visualizations.

4: Leverage Alerts

Detecting performance issues is useless if you can’t learn about them. This is why alerts and notifications should be at the heart of your Java APM strategy.

A great alerting mechanism should be versatile and highly configurable, and it should feature integrations with many different destinations, such as SMS, emails, and popular messaging applications like Slack.

It should also have a high signal-to-noise ratio. Otherwise, engineers quickly become overwhelmed by notification inflation and stop caring about them.

Java APM: Four Performance Tips to Adopt Today

With the more general APM best practices out of the way, let’s focus on performance tips specific to Java you can use to make sure your code performs better.

1: Beware of Your HashCode() Implementation

A proper implementation of HashCode() must ensure unique objects return different codes. This makes it so these objects can be added as keys in objects like HashMaps, where lookouts are very efficient.

Poor implementations of HashCode can lead not only to poor performance but to wrong application behavior.

2: Write GC-Friendly Code

In Java, like in many other languages, the garbage collection (GC) process works in generations. Newly born objects start in a generation and are promoted after surviving collections.

Understand how the GC process works and write code designed to play nicely with it. For instance, you can do the following:

  • Prefer primitive types over wrapper classes as often as possible
  • Avoid unnecessary object creation
  • Reuse objects—particularly larger ones—instead of creating new objects
  • Avoid unnecessary string concatenation, particularly inside loops

3: Use Logging Efficiently

Logging can be a source of performance issues as well. For starters, it’s possible for the way you log to create unnecessary objects, especially strings. Look out for optimization opportunities in such cases.

The call to log methods can be expensive, especially if they require another expensive operation. In these situations, you want to make sure to only call a method when it’s possible to log at this level. Here’s an example:

            logger.debug("Result: " + myObject.veryExpensiveOperation());

In this case, the method veryExpensiveOperation() will be executed, even if the configured logging level is set to ignore calls to debug. A better solution would be this:

        if (logger.isDebugEnabled()) {
                logger.debug("Result: " + myObject.veryExpensiveOperation());

4: Use the Database and ORM Efficiently

Databases can be a source of acute performance pains. A whole post wouldn’t suffice to cover all there is to know about this, but here are some key tips:

  • Improve your SQL queries to avoid the N+1 problem
  • Perform joins and orderings at the database level
  • Don’t forget to add indexes to the adequate table columns
  • When using object-relational mapping (ORM), tune your relationship mapping so you don’t generate more database activity than necessary


Modern software development is way too complex for a single person to master everything. Thus, it’s unrealistic to expect everyone to be a performance expert—or a security expert, a testing expert, and so on.

However, each engineer must write well-performing code, as performance is a key aspect of applications. So how can you solve this apparent dilemma?

Education is key. Since Java is a garbage-collected language, for example, having a solid understanding of how the GC process works will enable you to write code designed to play nicely with its assumptions and not create unnecessary allocations and pressure.

Though education is essential, it can only go so far. Even knowledgeable and experienced developers make mistakes, and these mistakes can be costly. This is why techniques such as APM and the tools making it possible are a valuable asset in your tool kit.

To get comprehensive and streamlined application performance monitoring, give SolarWinds™ Observability a try for free for 30 days.

This post was written by Carlos Schults. Carlos is a consultant and software engineer with experience in desktop, web, and mobile development. Though his primary language is C#, he has experience with a number of languages and platforms. His main interests include automated testing, version control, and code quality.

Related Posts