Java Backend Performance Optimization: Parallel Processing, Thread Pools, Caching, and Concurrency Techniques

This article provides a detailed guide on optimizing Java backend applications for high performance and scalability.

1. Parallel Processing

Using CompletableFuture enables concurrent execution of independent tasks such as fetching multiple price configurations, but excessive threads can cause scheduling overhead and degrade performance.

Test Cases

Comparisons between fully synchronous and fully asynchronous executions demonstrate that when the number of tasks or their execution time is small, synchronous processing can be faster.

private void test(){ long s = System.currentTimeMillis(); a(10); b(10); c(10); d(10); long e = System.currentTimeMillis(); System.out.println(e - s); }

private void test2(){ long s = System.currentTimeMillis(); List<CompletableFuture<?>> futures = new ArrayList<>(); futures.add(CompletableFuture.runAsync(() -> a(10))); futures.add(CompletableFuture.runAsync(() -> b(10))); futures.add(CompletableFuture.runAsync(() -> c(10))); futures.add(CompletableFuture.runAsync(() -> d(10))); CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join(); long e = System.currentTimeMillis(); System.out.println(e - s); }

2. Minimize Transaction Scope

Large transaction scopes increase lock contention. Use programmatic transactions with @Transactional only at the method level or control transaction boundaries manually to keep the scope minimal.

Programmatic Transaction Template

public interface TransactionControlService { <T> T execute(ObjectLogicFunction logic) throws Exception; void execute(VoidLogicFunction logic) throws Exception; }

3. Caching

Caching is a universal performance technique. Key considerations include expiration time, consistency, capacity limits, load balancing, concurrent reads/writes, cache penetration, and cache breakdown.

Optimization Measures

Data compression (e.g., using primitive arrays instead of wrapper types)

Pre‑loading hot data

Multi‑level cache (local + Redis)

Cache penetration handling (store a placeholder for missing keys)

Cache breakdown mitigation (staggered expiration)

4. Proper Thread‑Pool Usage

Configure core and maximum pool sizes based on CPU‑bound or I/O‑bound workloads, set appropriate keep‑alive times, choose suitable work queues, and monitor pool metrics to avoid resource exhaustion.

private static final ExecutorService executor = new ThreadPoolExecutor(2, 4, 1L, TimeUnit.MINUTES, new LinkedBlockingQueue<>(100), new ThreadFactoryBuilder().setNameFormat("common-pool-%d").build(), new ThreadPoolExecutor.CallerRunsPolicy());

5. Service Warm‑up

Pre‑initialize resources such as thread‑pool core threads, database connections, and caches during application startup to eliminate latency spikes on first request.

6. Cache‑Line Alignment

Accessing data in row‑major order aligns with CPU cache lines, dramatically reducing memory latency compared to column‑major access.

public class CacheLine { public static void main(String[] args){ int[][] arr = new int[10000][10000]; long s = System.currentTimeMillis(); for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr[i].length; j++) { arr[i][j] = 0; } } long e = System.currentTimeMillis(); System.out.println(e - s); } }

7. Reduce Object Creation

Avoid wrapper types and mutable objects when possible; prefer primitives, immutable strings, and object pools to lower GC pressure.

private static void testInt(){ int sum = 1; for (int i = 1; i < 50000000; i++) { sum++; } System.out.println(sum); }

8. Concurrency Control

Choose the smallest appropriate lock granularity: volatile for simple visibility, CAS for lock‑free updates, synchronized for object/class locks, spin locks for short critical sections, segmented locks (e.g., ConcurrentHashMap), and read‑write locks for read‑heavy scenarios.

Copy‑On‑Write Collections

CopyOnWriteArraySet excels in read‑heavy workloads but suffers when writes dominate.

9. Asynchronous Design

Use async patterns (threads, MQ, reactive streams) to return immediate acknowledgments and process results later, improving overall throughput.

10. Loop Optimizations

Reduce loop iterations with efficient algorithms, batch database queries, and cache intermediate results.

11. Reduce Network Payload

Trim unnecessary fields, use compact serialization formats (JSON, protobuf), and apply compression (GZIP, ZLIB) to lower bandwidth usage.

12. Reduce Service Dependencies

Design micro‑services to avoid circular calls, duplicate requests, and tightly coupled layers; employ data redundancy, result caching, and message queues to decouple services.

Disclaimer: The shared material is collected from the internet, the copyright belongs to the original authors, and it is provided for learning and exchange only. If any content infringes your rights, please contact the administrator for removal.