Common Causes of 100% CPU Usage in Java Backend Systems and Their Solutions

Preface

cpu使用率100%

is a headache‑inducing problem because its causes are varied and often non‑deterministic, appearing after the system has been running for a while.

We summarize several CPU‑100% incidents we encountered with our team to help others facing similar issues.

1. Retrieving Too Much Data at Once

In a restaurant‑related business system, our downstream service subscribed to a Kafka topic to receive updated dish data. The service ran fine for over a year, but one afternoon we received a flood of CPU‑100% alerts.

Investigation revealed a bug: instead of incremental updates, the system fetched the entire dish dataset each time, causing massive data parsing and frequent full GC, which spiked the CPU.

2. Kafka Automatic Acknowledgement

Our sub‑system used Kafka for communication. Upstream systems wrote business IDs to the database and sent them via Kafka. Downstream consumers read the IDs and called upstream APIs to fetch full data.

Initially we used Kafka’s automatic acknowledgement to reduce code, which worked while traffic was low. As the user base grew, the volume of Kafka messages increased, leading to sustained CPU‑100% usage.

Switching the consumer to manual acknowledgement resolved the issue.

3. Infinite Loops

Developers often write infinite loops ( while, for, forEach) or infinite recursion. These keep the CPU busy by continuously updating a register with the loop count or recursion depth.

In JDK 1.7, certain multithreaded HashMap put operations could also cause linked‑list loops, further increasing CPU load.

4. Multithreaded Data Import

A colleague transformed a single‑threaded Excel import of supplier data into a multithreaded version using a thread pool, which dramatically improved import speed.

However, the increased number of threads caused frequent context switches, consuming excessive CPU resources and raising CPU usage.

5. Bulk File Synchronization

In a gaming platform, we generated static HTML sites for each game using FreeMarker templates. During a holiday event, we updated all templates and needed to regenerate and sync every site’s HTML files to the web server.

The massive file synchronization caused the application server’s CPU to spike.

6. Deadlocks

To protect shared resources in concurrent scenarios, we use synchronized or Lock. When a thread holds one lock and waits for another that a second thread holds, a deadlock occurs, leading to CPU spikes.

"pool-4-thread-1" prio=10 tid=0x00007f27bc11a000 nid=0x2ae9 waiting on condition [...]

This classic deadlock pattern was observed in our code.

7. Inefficient Regular Expressions

Poorly written regexes can cause massive backtracking in Java’s NFA engine, dramatically increasing CPU usage.

^([hH][tT]{2}[pP]://|[hH][tT]{2}[pP][sS]://)(([A-Za-z0-9-~]+).)+([A-Za-z0-9-~/])+$

Minimizing backtracking in regex patterns is essential for performance.

8. Time‑Consuming Calculations

Real‑time calculations such as computing discounted prices or aggregating large data sets can be CPU‑intensive, especially under high concurrency, leading to sustained high CPU usage.