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

1. Parallel Processing

Using CompletableFuture to run independent price‑fetching tasks in parallel can speed up price‑query chains, but excessive threads may cause scheduling overhead; choose thread‑pool size based on I/O‑ or CPU‑bound nature.

Is CompletableFuture a silver bullet?

While it simplifies asynchronous code, overusing it for fast tasks can increase latency due to thread‑context switches.

Test Cases

Four methods (a, b, c, d) are executed synchronously and asynchronously to compare execution time.

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 testAsync(){ long s=System.currentTimeMillis(); List<CompletableFuture<?>> list=new ArrayList<>(); CompletableFuture.runAsync(()->a(10)).thenAccept(v->{}); /* … */ CompletableFuture.allOf(list.toArray(new CompletableFuture[0])).join(); long e=System.currentTimeMillis(); System.out.println(e-s); }

Results show that when tasks are short or few, synchronous execution may be faster.

2. Minimize Transaction Scope

Large transaction scopes increase lock contention; use programmatic transactions instead of the method‑level @Transactional to control exact boundaries.

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

@Service public class TransactionControlServiceImpl implements TransactionControlService { /* ... */ }

3. Caching

Caching is a universal performance technique; key considerations include expiration time, consistency, capacity limits, load balancing, concurrent read/write, cache penetration, and cache breakdown.

Optimization Techniques

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

Pre‑loading hot data.

Using multi‑level caches (local + Redis).

4. Proper Thread‑Pool Usage

Thread pools should be created with ThreadPoolExecutor rather than Executors to explicitly set core size, max size, keep‑alive time, work queue, thread factory, and rejection policy.

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());

Core pool size should match CPU cores for CPU‑bound tasks or be 2× for I/O‑bound tasks; calculate using Runtime.getRuntime().availableProcessors() and blocking coefficient.

5. Service Warm‑up

Pre‑initialize resources such as thread‑pool core threads ( prestartAllCoreThreads()), database connections, and caches during application startup to avoid latency spikes.

6. Cache‑Line Alignment

CPU cache lines (typically 64 bytes) affect array traversal performance; iterating row‑wise leverages spatial locality, while column‑wise access incurs cache misses.

public class CacheLine { public static void main(String[] args){ int[][] arr = new int[10000][10000]; /* row‑wise write */ } }

Padding objects to occupy a full cache line prevents false sharing between threads.

class Padding { long p1, p2, p3, p4, p5, p6, p7; } class T extends Padding { volatile long x; }

7. Reduce Object Creation

Avoid wrapper types and use primitives; prefer immutable objects (e.g., string literals) and static factories or enums for singletons; reuse collections via view objects or object pools.

public class Main { public static void main(String[] args){ long s=System.currentTimeMillis(); testInteger(); long e=System.currentTimeMillis(); System.out.println(e-s); /* … */ }

8. Concurrency Control

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

public boolean add(E e){ synchronized(lock){ Object[] es = getArray(); int len = es.length; es = Arrays.copyOf(es, len+1); es[len]=e; setArray(es); return true; } }

9. Asynchronous Design

Use threads, message queues, event notifications, or reactive programming to decouple request receipt from processing, improving throughput.

10. Loop Optimizations

Batch database queries, cache intermediate results, and use parallel streams for CPU‑intensive calculations.

Map<String,User> userMap = userMapper.queryByIds(userIds); for(String id: userIds){ User u = userMap.get(id); /* … */ }

11. Reduce Network Payload

Trim unnecessary fields, choose compact serialization formats (e.g., protobuf), and compress payloads with GZIP or ZLIB.

byte[] compressed = ZipUtil.gzip(sb.toString(), CharsetUtil.UTF_8);

12. Minimize Service Dependencies

Design micro‑services to avoid circular calls, duplicate requests, and tight coupling; use data duplication, result caching, and message queues to reduce cross‑service latency.

Source: juejin.cn/post/7271276760905023549