Mastering Scale‑Up: How to Maximize Single‑Server Concurrency for Web Apps

Why High Concurrency Matters

In today’s Internet, companies must design systems that can sustain high concurrent connections from the start; treating traffic spikes as a “happy trouble” can lead to failure.

Scale‑up vs Scale‑out

Scale‑up (vertical scaling) improves a single server’s hardware and software to increase capacity, focusing on cost. Scale‑out (horizontal scaling) adds more service nodes in a distributed architecture, focusing on overall service capability.

C10K and C10M

The historic C10K problem described the difficulty of handling ten thousand concurrent connections on a single machine. Modern hardware and algorithms have solved C10K, but the new challenge is C10M – ten million concurrent connections.

Process, Thread, and Coroutine

A process is an OS‑level execution entity; a thread is the smallest schedulable unit within a process; a coroutine (user‑level thread) can be scheduled by the program with far lower overhead.

Process – heavy, context‑switch costly, generally blocking.

Thread – lighter than a process but still incurs context‑switch and thread‑safety complexity, also blocking.

Coroutine – user‑level, minimal context‑switch, enables writing asynchronous code in a synchronous style.

Common Coroutine Platforms

Golang – goroutine

Erlang – process

Lua – coroutine

Python – coroutine

C# – fiber

Scala – actor

Event‑Driven Model

Event‑driven programming reacts to events (e.g., mouse click) by invoking callbacks. It is inherently asynchronous and non‑blocking, widely used in servers such as Nginx and languages like Node.js.

Advantages: high efficiency, low resource consumption. Drawbacks: callback hell, O(N) event polling overhead.

Choosing the Right Model

Both event‑driven and coroutine approaches dominate modern high‑concurrency solutions. The author favors coroutines for their simplicity, noting that Golang’s implementation slightly outperforms Node.js in benchmarks.