Boost Java Application Performance: Practical Tips, Tools, and JVM Tuning

21CTO Guide: How developers can make Java applications run at optimal performance.

Introduction

We discuss methods to improve Java application performance, starting with defining quantifiable performance goals, using tools to measure and monitor, identifying bottlenecks, and applying code‑level optimizations and JVM‑specific tuning.

Optimization Goals

Before improving performance, understand non‑functional requirements such as scalability, performance, and availability. Typical web‑app metrics include average response time, average concurrent users, and peak QPS.

Load‑Testing Tools

Tools like Gatling and Retrace (Stackify) help track and optimize Java performance. Gatling offers strong HTTP support for load testing, while Retrace provides APM features, code analysis, and runtime metrics without degrading application performance.

Gatling Load Test Example

Define a scenario of 200 users each generating 10,000 requests. Create a Scala simulation file:

class EmployeeSimulation extends Simulation {
    val scn = scenario("FetchEmployees").repeat(10000) {
        exec(
            http("GetEmployees-API")
                .get("http://localhost:8080/employees")
                .check(status.is(200))
        )
    }
    setUp(scn.users(200).ramp(100))
}

Run the test with:

$GATLING_HOME/bin/gatling.sh -s basic.EmployeeSimulation

Monitoring with Retrace

Register for a free trial on Stackify, install the Retrace proxy on the server, and add the application in the Retrace dashboard to monitor JVM memory, threads, and class usage, as well as CPU and I/O.

Retrace can automatically detect issues in SQL, Redis, HTTP servers, etc.

Code‑Level Optimizations

StringBuilder vs String Concatenation

public String stringAppendLoop() {
    String s = "";
    for (int i = 0; i < 10000; i++) {
        if (s.length() > 0) s += ", ";
        s += "bar";
    }
    return s;
}

public String stringAppendBuilderLoop() {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 10000; i++) {
        if (sb.length() > 0) sb.append(", ");
        sb.append("bar");
    }
    return sb.toString();
}

Using StringBuilder is significantly faster.

Avoid Deep Recursion

public int factorial(int n) {
    if (n == 0) return 1;
    else return n * factorial(n - 1);
}

private int factorial(int n, int accum) {
    if (n == 0) return accum;
    else return factorial(n - 1, accum * n);
}

public int factorial(int n) {
    return factorial(n, 1);
}

Tail‑recursive forms reduce stack‑overflow risk; JVM languages like Scala already optimize tail recursion.

Use Regex Sparingly

Prefer built‑in string methods (e.g., replaceAll, split) for better performance, or cache compiled Pattern objects:

static final Pattern HEAVY_REGEX = Pattern.compile("(((X)*Y)*Z)*");

Thread Management

Creating many threads is costly; use thread pools via ExecutorService or Java 7 Fork/Join framework to reuse threads efficiently.

JVM Tuning

Heap Size

Determine appropriate heap size based on number of deployed apps, loaded classes, cache requirements, and thread count. Real load tests are essential for accurate sizing.

Garbage Collector Selection

Modern GC algorithms reduce pause times; understand GC logs, heap dumps, and use appropriate collector settings based on workload.

Database Performance

Connection Pooling

Use lightweight pools like HikariCP to mitigate expensive connection creation.

JDBC Batch Processing

Batch multiple statements in a single round‑trip; PreparedStatement is ideal for batch execution.

Statement Caching

Cache prepared statements on client or server side to avoid repeated parsing.

Scaling and Caching

Employ database replication, sharding, and external caches (Redis, Ehcache, Memcached) to improve throughput and reduce load.

Conclusion

We covered load testing, APM monitoring, Java code best practices, JVM tuning, JDBC optimizations, and architectural scaling. Applying these techniques helps you build high‑performance, scalable Java applications without worrying about performance bottlenecks.

Author: Qiao Qiao Source: 21CTO Community