Common Backend Interface Optimization Techniques and Practices

In a recent project I encountered a 504 timeout caused by an Nginx request timeout set to 10 seconds; after thorough performance tuning the interface response time dropped from 11.3s to 170ms. Below are the general solutions I applied.

1. Batch Thinking: Batch Database Operations

Before:

//for loop single insert
for(TransDetail detail:transDetailList){
  insert(detail);
}

After:

batchInsert(transDetailList);

Analogy: moving 10,000 bricks with an elevator that can carry up to 500 bricks at a time—batching is far more efficient.

2. Asynchronous Thinking: Off‑load Time‑Consuming Operations

Place long‑running tasks (e.g., matching bank codes during a transfer) into asynchronous processing using thread pools or message queues, reducing the API's blocking time.

3. Space‑for‑Time: Proper Use of Caches

Cache frequently accessed data (e.g., using Redis, JVM local cache, memcached, or a simple Map) to avoid repeated database queries.

4. Prefetch Thinking: Initialize Data into Cache Early

Pre‑populate cache with data that will be needed later, such as user‑profile or live‑stream information, to avoid on‑demand computation delays.

5. Pooling Thinking: Pre‑allocate and Reuse Resources

Use thread pools, connection pools (TCP Keep‑Alive, HttpClient, DB pools) to avoid the overhead of creating and destroying resources repeatedly.

6. Event‑Callback Thinking: Avoid Blocking Waits

Instead of blocking on a slow external system B, employ an event‑driven model (e.g., IO multiplexing) to continue other work and handle the result via callbacks.

7. Parallel Remote Calls

Convert sequential remote calls (user info, banner, popup) into parallel invocations, dramatically cutting total latency.

8. Lock Granularity: Avoid Overly Coarse Locks

Lock only the critical section (e.g., synchronize on the shared list rather than the whole object) to improve concurrency.

9. Temporary File Storage

When database inserts become a bottleneck, write bulk data to a file first and asynchronously load it later, achieving a ten‑fold speedup in some cases.

10. Index Optimization

Add missing indexes, verify their effectiveness, and design them reasonably (avoid redundant indexes, limit to 5 per table, avoid low‑cardinality columns, consider covering indexes, and use FORCE INDEX only when necessary).

11. SQL Tuning

Beyond indexes, rewrite queries for better execution plans, as detailed in related articles.

12. Avoid Large Transactions

Keep transactions short; avoid embedding remote RPC calls or heavy processing inside a transaction to prevent connection pool exhaustion.

13. Deep Pagination

Replace LIMIT offset, count with tag‑record or delayed‑join methods to prevent scanning massive row offsets.

14. Program Structure Optimization

Eliminate unnecessary object creation, simplify conditional logic, and reorder checks to reduce execution frequency.

15. Compress Transfer Content

Compress payloads (e.g., using gzip) to reduce bandwidth usage and improve response time.

16. Massive Data Handling: Consider NoSQL

For very large datasets, offload to Elasticsearch, HBase, or other NoSQL stores instead of forcing relational databases.

17. Reasonable Thread‑Pool Design

Configure core and max thread counts appropriately, size the work queue to avoid OOM, and isolate business‑critical pools from peripheral workloads.

18. Machine‑Level Issues

Monitor for full GC pauses, thread saturation, and unclosed IO resources; apply limits, proper resource cleanup, and profiling to mitigate these problems.