This article examines why Go programs often suffer from low CPU usage, explores seven common scheduler pitfalls through real production cases, and provides concrete techniques—such as separating I/O from CPU work, tuning GOMAXPROCS, and using worker pools—to boost utilization from 30% to 95% and dramatically improve latency.
This article explains how Youzan transformed its Kubernetes clusters from static over‑commit scheduling to load‑balanced mixed workloads using Koordinator and the Longxi kernel, achieving higher CPU utilization, lower costs, and better resource management for both online and offline services.
This article experimentally examines how thread count, CPU‑bound versus I/O‑bound workloads, and context‑switch overhead affect CPU utilization in Java, presents a practical formula for estimating optimal threads, and advises testing and tuning rather than relying on fixed rules.
When an RTOS has no runnable tasks and all tasks are delayed or waiting for events, the CPU does not stay idle but executes the system's idle task or thread, which may simply loop forever unless the developer adds custom work.
Performance testing involves monitoring various metrics to assess system behavior under different conditions, including response time, throughput, CPU usage, memory utilization, and error rates.
During a load‑test where QPS and TPS appear normal, the CPU usage climbs unexpectedly, leading to a step‑by‑step investigation that reveals excessive row reads caused by accumulating task records, and presents practical fixes and deeper insights into database read behavior.
Xiaohongshu’s cloud‑native platform adopted a four‑stage mixed‑workload scheduling strategy—reusing idle nodes, whole‑machine time‑sharing, normal mixed pools, and a unified scheduler (Tusker) that coordinates CPU, GPU and memory across Kubernetes and YARN—boosting average cluster CPU utilization from under 20 % to over 45 % and delivering millions of low‑cost core‑hours while preserving QoS for latency‑sensitive, mid, and batch jobs.
This article debunks common thread‑count myths by running Java CPU‑bound and I/O‑bound experiments on a 6‑core/12‑thread Ryzen, showing how core count, context‑switching overhead, and I/O wait time affect CPU utilization and guiding practical thread‑pool sizing.
This article explains how to size a thread pool by understanding CPU core limits, I/O wait effects, empirical testing on a multi‑core machine, and a practical formula, while emphasizing that real‑world workloads require iterative performance testing to find the best thread count.
This article presents the design and evaluation of the Remote Aware Load Balance (RALB) algorithm applied to JD’s search‑recommendation architecture, describing its CPU‑centric load‑balancing principles, implementation details, functional verification, throughput and boundary testing, and the observed improvements in CPU utilization and overall system performance.
This article explains how to correctly obtain CPU utilization inside containers, compares host and container metrics, describes the use of lxcfs and cgroup files (including cgroup V1/V2) for accurate measurement, and clarifies why container statistics omit nice, irq, and softirq fields.
This article explains how Linux computes CPU utilization shown by the top command, detailing the role of /proc/stat, kernel_cpustat, timer interrupts, sampling intervals, and how user, nice, system, irq, softirq, iowait, and idle times are accumulated and reported.
This article explains Linux process states, how the kernel calculates load average, the relationship between load and CPU utilization, and provides a systematic approach with tools and commands to identify resource bottlenecks, differentiate high‑load/high‑CPU scenarios from high‑load/low‑CPU cases, and pinpoint problematic processes and threads.
This article analyzes Baidu's offline mixed‑tenant technology that combines online and offline workloads on the same physical servers, detailing the resource‑usage problems, dynamic resource views, priority schemes, isolation mechanisms, high‑performance scheduling, and future directions for cloud‑native clusters.
Understanding Linux load average and CPU utilization, this guide explains process states, how load is calculated, the difference between load and CPU usage, common bottlenecks, and step‑by‑step troubleshooting techniques using tools like top, vmstat, pidstat, iostat, and perf.
This article explains CPU time‑slice scheduling, defines CPU utilization as T2/T1, and demonstrates through C programs how different loops affect measured CPU usage, showing why multi‑core systems can report over‑100% utilization while single‑core systems cannot.
This article walks through Linux process states, fork/exec creation, CPU vs load metrics, network I/O models, and a real‑world Nginx high‑load case, showing how strace, accept_mutex, and SO_REUSEPORT can resolve the issue.
This article explains why multithreading improves program performance, distinguishes latency reduction from throughput increase, and provides practical formulas to determine the ideal number of threads for both I/O‑bound and CPU‑bound workloads, helping you fully utilize hardware resources.
This article explains what Linux load average actually measures, distinguishes it from CPU utilization, and demonstrates how to interpret and monitor load with practical stress‑test scenarios using tools like uptime, mpstat, and pidstat.
Understanding Linux load average and CPU utilization, this guide explains process states, how load is calculated, the difference between load and CPU usage, common bottlenecks, and practical troubleshooting steps using tools like top, vmstat, pidstat, iostat, and perf to pinpoint performance issues.
The article explains that high concurrency in distributed systems is measured by QPS, but its essence lies in effectively utilizing CPU resources, discusses control‑variable analysis of the HTTP request flow, compares PHP‑Swoole and Java‑Netty implementations, and shows how coroutine‑based designs can dramatically boost throughput when I/O blocking is present.
This article explains Sentinel's role in microservice rate limiting, details a Docker-specific bug where CPU utilization is incorrectly reported, clarifies the difference between CPU load and utilization, and outlines the code fix and its remaining limitations.
Tencent’s TLinux team introduced a kernel‑level mixed‑deployment framework that adds an offline scheduling class and load‑balancing algorithm, enabling online tasks to instantly pre‑empt offline work and boosting whole‑machine CPU utilization to as high as 90% while preserving latency‑sensitive service performance.
This article explains that high concurrency is fundamentally about efficiently squeezing CPU resources, discusses the evolution of concurrency models, presents a control‑variable analysis of HTTP request flow, and compares PHP‑Swoole with Java‑Netty through detailed benchmark results and code examples.
This article explains why simply increasing thread‑pool size often fails, describes how CPU, network and disk I/O affect request handling, introduces the concept of context switching, and provides practical formulas and guidelines for calculating the optimal number of threads in a Java backend service.
The article examines how traditional synchronous and semi‑synchronous API gateways can fail under high load by analyzing CPU utilization, disk I/O, and network latency, and offers practical monitoring metrics and mitigation strategies to prevent cascading failures in large‑scale systems.
This article explains why the traditional %CPU metric can be deceptive, describes how CPU stalls and memory bottlenecks affect perceived utilization, and offers practical guidance on using IPC and performance counters to obtain a more accurate view of system performance.
When system performance degrades, start by examining OS reports—CPU usage, memory consumption, disk and network I/O, and connection counts—using tools like Windows PerfMon, Linux vmstat, iostat, top, iftop, or Wireshark to pinpoint bottlenecks before diving into code.
The article explains how Unix-like systems calculate load average using an exponentially damped weighted moving average, how the values reflect CPU and I/O contention on single- and multi‑CPU machines, and why different kernel implementations may count processes and threads differently, affecting performance monitoring.
