Essential Backend Performance Optimization Strategies You Must Know

This article briefly introduces common performance optimization strategies used in backend service development.

1. Code

Optimizing code is the top priority; replace inefficient implementations with more efficient algorithms or solutions whenever possible.

2. Database

Database optimization generally covers three aspects:

SQL tuning: use slow query logs, EXPLAIN, PROFILE, etc.

Connection pool tuning: choose an efficient pool and adjust parameters based on monitoring and workload.

Architectural level: read‑write separation, master‑slave load balancing, sharding, etc.

3. Cache

Classification

Local caches (HashMap, ConcurrentHashMap, Ehcache, RocksDB, Guava Cache) and cache services (Redis, Tair, Memcached).

Design key points

When to update cache, ensuring reliability and timeliness. Two basic update strategies: real‑time updates via change messages, or setting a short expiration (e.g., 5 minutes) as a fallback.

Handling cache capacity, eviction (e.g., LRU), alerts, and expiration for non‑essential keys.

Whether cache loss is acceptable; if not, use persistent caches like Redis with RDB or AOF.

Cache problems

Cache penetration : requests for data that does not exist in cache or DB, often malicious. Solutions: input validation, cache null values with short TTL.

Cache breakdown : high concurrency on expired hot data causing DB overload. Solutions: keep hot data never expiring, or use mutex locks. Example implementation:

public String get(String key) {
    String value = redis.get(key);
    if (value == null) { // cache miss
        if (redis.setnx(key_mutex, 1, 3 * 60) == 1) { // acquire lock
            value = db.get(key);
            redis.set(key, value, expire_secs);
            redis.del(key_mutex);
        } else {
            Thread.sleep(50);
            return get(key); // retry
        }
    }
    return value;
}

Cache avalanche : many keys expire simultaneously, overwhelming DB. Solutions: randomize TTLs, distribute hot data across nodes, keep hot data permanent.

Cache update : Cache‑Aside pattern – on miss load from DB and populate cache; on hit return cache; on write update DB then invalidate cache.

4. Asynchronous

Use cases

When the client does not need immediate results, offload extra work to asynchronous processing.

Benefits

Shortens response time, improving user experience.

Prevents long‑running threads from exhausting the thread pool.

Boosts overall service throughput.

Implementation

Thread/Thread‑pool: spawn separate threads or use a pool to handle tasks outside the I/O thread. For large payloads, introduce a BlockingQueue for batch processing.

Message queue (MQ): use MQ middleware to decouple tasks; the queue guarantees reliable delivery to consumer services.

5. NoSQL

Difference from cache

NoSQL is used as a database, requiring durability and availability guarantees, unlike cache which may be volatile.

Use cases

Suitable when data is not relational, does not need transactions, and write frequency is high (e.g., HBase, Elasticsearch, OpenTSDB for time‑series data).

6. Multithreading and Distributed

Use cases

Offline jobs, asynchronous tasks, big‑data processing, long‑running tasks.

Best practices

Prefer single‑machine multithreading when capacity suffices; otherwise adopt multi‑machine solutions with distributed schedulers (e.g., XXL‑Job). Thread pools improve performance and provide throttling.

7. JVM Optimization

For Java backends, JVM tuning can improve performance. Monitor metrics such as memory usage, CPU load, GC count/time, and GC logs.

Common tools: jstat, jps, jstack, jmap, show‑busy‑java‑threads, Arthas.

Typical tuning directions include heap size (‑Xms, ‑Xmx) and garbage‑collection strategy, after understanding JVM internals.