Tagged articles
thundering herd
15 articles · Page 1 of 1
This article explains the thundering herd problem in Nginx when many workers compete for new connections and provides four practical solutions—accept_mutex, reuseport, multi_accept, and keepalive_timeout—along with configuration examples to improve high‑concurrency performance.
accept_mutexhigh concurrencykeepalive_timeout
0 likes · 3 min read

The article explains the thundering herd problem in Linux—how multiple processes or threads wake up simultaneously for a single event, causing wasted CPU cycles and lock overhead—then examines its impact on accept, poll, and epoll, and presents practical solutions such as EPOLLEXCLUSIVE, SO_REUSEPORT, thread pools, and spin‑locks.
Linuxthundering herd
0 likes · 42 min read

The thundering herd problem in Linux causes multiple processes or threads to wake up simultaneously for a single event, leading to wasted CPU cycles, excessive context switches, lock contention, and severe performance degradation, but it can be mitigated with kernel tweaks, epoll flags, SO_REUSEPORT, thread pools, and other strategies.
EpollMultithreadingaccept
0 likes · 45 min read

This article explains the thundering herd issue in Nginx’s multi‑process model, detailing both accept‑ and epoll‑related herd problems, their causes, and practical mitigation techniques such as kernel‑level improvements, Nginx’s accept_mutex, dynamic load balancing, and the SO_REUSEPORT feature.
EpollSO_REUSEPORTaccept_mutex
0 likes · 11 min read

This article explains the thundering herd phenomenon in multi‑process servers, describes Nginx's master‑worker architecture and its use of epoll, and evaluates three mitigation techniques—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—along with relevant source code examples.
EpollSO_REUSEPORTaccept_mutex
0 likes · 9 min read

This article explains the thundering herd phenomenon in multi‑process/thread servers, details its performance costs, demonstrates the issue with accept() and epoll_wait() through C examples, explores thread‑level herd, and presents mitigation techniques such as accept mutexes, SO_REUSEPORT, and Nginx's handling.
ConcurrencyEpollLinux kernel
0 likes · 20 min read

This article explains the Linux thundering herd phenomenon, its impact on processes, threads, and epoll, demonstrates it with C code examples, analyzes system overhead, and presents mitigation techniques such as accept mutex, SO_REUSEPORT, and proper locking to improve server performance.
EpollLinuxSO_REUSEPORT
0 likes · 19 min read

This article explains the thundering herd issue caused by multiple workers waiting on the same socket event, describes how the SO_REUSEPORT socket option eliminates the wasteful wake‑ups, and shows step‑by‑step how Workerman can be configured to use reusePort for better concurrency and throughput.
BackendSocketreuseport
0 likes · 12 min read

This article explains the thundering herd effect, walks through Nginx's master‑worker architecture and its use of epoll, and compares three practical solutions—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—to eliminate wasted wake‑ups in high‑concurrency servers.
BackendConcurrencyEpoll
0 likes · 9 min read

This article explains the thundering herd phenomenon in multi‑process servers, walks through Nginx’s master‑worker architecture and its use of epoll, and compares three practical mitigation techniques—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—complete with code excerpts and configuration examples.
BackendConcurrencyEpoll
0 likes · 9 min read

This article explains the thundering herd effect in multi‑process servers, describes Nginx's master‑worker architecture and its use of epoll, then compares three mitigation techniques—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—showing code snippets and performance insights.
EpollSO_REUSEPORTaccept_mutex
0 likes · 9 min read

This article examines various strategies—including cache warm‑up, staggered expirations, aggregated caching, queuing, locking, rate‑limiting, backup caches, client‑side caches, and default empty values—to mitigate cache breakdown and service avalanche during peak traffic periods.
Cachingcache avalanchethundering herd
0 likes · 8 min read

The article explains the thundering herd problem where many processes wake for a single event, describes Linux’s kernel fixes for accept() and partial epoll solutions, and details how Nginx avoids the issue using a custom inter‑process accept mutex and lock design.
ConcurrencyEpollLinux kernel
0 likes · 14 min read

This article explains the thundering herd phenomenon in Linux network programming, demonstrates how to reproduce it with multi‑process accept and epoll examples, analyzes why modern kernels often suppress it, and discusses mitigation techniques such as mutex locking in Nginx.
ConcurrencyEpollLinux
0 likes · 14 min read


21CTOApr 25, 2016 · Backend Development
This article explores why Memcached expiration can cause sudden DB overload and presents five practical strategies—including periodic DB refresh, lock‑based queries, dual‑key schemes, and time‑embedded values—to proactively update caches and keep backend performance stable.
BackendDistributed CachingJava
0 likes · 8 min read
