Practical Java Performance Optimization: Metrics, Bottleneck Identification, and Governance Strategies

Introduction – Based on Java and the author’s experience, common performance‑optimization practices are presented.

1. Performance Metrics

UI interface latency should be rt < 200ms , with 99% of requests meeting this threshold. Non‑UI metrics include pipeline task stability and minimum latency requirements (e.g., logs must be searchable within 5 seconds).

2. Bottleneck Discovery

Baseline reserves – When a performance issue appears, frontline developers can use recent deployment, performance, link, TPS, and RT baselines to locate the problem quickly.

Typical case: a sudden TPS spike caused by 0‑yuan promotional coupons generated a flood of orders, illustrating the need for business‑level flow control.

Open‑source diagnostic tool – Arthas is recommended for Java process inspection, offering features such as classpath analysis, low overhead, and easy integration with scripts.

Example usage:

@Override
public Location getLocation(Integer id) {
    if (id <= 0) {
        LOGGER.warn("getLocation failed, id less than 0, id = {}", id);
        return null;
    }
    return Optional.ofNullable(locationMapper.get(id))
            .orElse(mRemoteLocationService.getLocationById(id));
}

Optimized version (lazy remote call):

@Override
public Location getLocation(Integer id) {
    if (id <= 0) {
        LOGGER.warn("getLocation failed, id less than 0, id = {}", id);
        return null;
    }
    return Optional.ofNullable(locationMapper.get(id))
            .orElseGet(() -> mRemoteLocationService.getLocationById(id));
}

Common code‑level performance bugs include unnecessary loops, large transactions, thread‑pool misuse, and inefficient regular expressions.

3. Governance Measures

Near‑User Optimizations – Use web‑server cache, CDN, and regional deployment to reduce latency for hot cities.

Application‑Layer Optimizations

Write concise call paths and validate input parameters early.

Minimize data transfer; design APIs to return only required fields.

Use appropriate libraries (JDK, Spring, MyBatis, MySQL, Redis, Elasticsearch) correctly; e.g., pre‑size HashMap with Maps.newHashMapWithExpectedSize(1024) .

Choose Elasticsearch index settings wisely (field indexing, doc_values, routing, pagination methods).

Extreme Optimizations – Leverage Java Zero‑Copy, ByteBuffer pooling, efficient concurrency models, and reduce system calls.

Technical Solutions

Space‑for‑Time : Pre‑compute and store derived data (e.g., cache user statistics, recipe recommendations) to avoid costly runtime calculations.

Splitting : Divide large tasks into smaller ones with dedicated thread pools; split microservices into core and non‑core components, or separate search services for high‑TPS demands.

Data Sharding : Apply database sharding (horizontal/vertical) when tables exceed tens of millions of rows or hundreds of gigabytes.

Asynchronous Processing : Convert synchronous calls to parallel async calls to reduce total latency (e.g., parallel stock, price, coupon, promotion queries). Use eventual consistency via local tables + scheduled jobs or message middleware.

Conclusion – Proactively monitor business and JVM metrics, perform baseline testing for new features, maintain high‑quality code, and continuously enrich technical reserves to design robust performance‑oriented solutions.