Understanding High Concurrency: CPU Utilization, Context Switching, and Performance Comparison of PHP Swoole vs Java Netty

High concurrency is a key performance metric for distributed internet systems, defined as the number of requests a system can handle simultaneously (QPS). The article explains that true high concurrency is about effectively squeezing CPU resources rather than merely adding machines.

It introduces the control variable method, reviewing a classic C/S HTTP request flow and emphasizing that each layer—load balancer, service, cache, persistence—must be high‑availability and high‑performance to achieve high concurrency.

The discussion then shifts to concurrency models, tracing the evolution from forked processes to thread pools, epoll‑driven event loops (e.g., Nginx, Node.js), and finally coroutines, highlighting that coroutine context switches occur in user space without costly CPU or kernel context switches.

Practical benchmark setups are presented: a PHP‑Swoole service and a Java‑Netty service, each running in Docker containers with two CPU cores. The Docker‑compose configuration is shown below:

# java8
version: "2.2"
services:
  java8:
    container_name: "java8"
    hostname: "java8"
    image: "java:8"
    volumes:
      - /home/cg/MyApp:/MyApp
    ports:
      - "5555:8080"
    environment:
      - TZ=Asia/Shanghai
    working_dir: /MyApp
    cpus: 2
    cpuset: 0,1
    mem_limit: 1024m
    memswap_limit: 1024m
    mem_reservation: 1024m
    tty: true

# php7-sw
version: "2.2"
services:
  php7-sw:
    container_name: "php7-sw"
    hostname: "php7-sw"
    image: "mileschou/swoole:7.1"
    volumes:
      - /home/cg/MyApp:/MyApp
    ports:
      - "5551:8080"
    environment:
      - TZ=Asia/Shanghai
    working_dir: /MyApp
    cpus: 2
    cpuset: 0,1
    mem_limit: 1024m
    memswap_limit: 1024m
    mem_reservation: 1024m
    tty: true

The core server code for both languages is also included unchanged.

<?php
use Swoole\Server;
use Swoole\Http\Response;

$http = new swoole_http_server("0.0.0.0", 8080);
$http->set([
    'worker_num' => 2
]);
$http->on("request", function ($request, Response $response) {
    $response->end('Hello World');
});
$http->on("start", function (Server $server) {
    go(function () use ($server) {
        echo "server listen on 0.0.0.0:8080 \n";
    });
});
$http->start();

public static void main(String[] args) throws Exception {
    final SslContext sslCtx;
    if (SSL) {
        SelfSignedCertificate ssc = new SelfSignedCertificate();
        sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
    } else {
        sslCtx = null;
    }
    EventLoopGroup bossGroup = new NioEventLoopGroup(2);
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    try {
        ServerBootstrap b = new ServerBootstrap();
        b.option(ChannelOption.SO_BACKLOG, 1024);
        b.group(bossGroup, workerGroup)
         .channel(NioServerSocketChannel.class)
         .handler(new LoggingHandler(LogLevel.INFO))
         .childHandler(new HttpHelloWorldServerInitializer(sslCtx));
        Channel ch = b.bind(PORT).sync().channel();
        System.err.println("Open your web browser and navigate to " +
            (SSL? "https" : "http") + "://127.0.0.1:" + PORT + '/');
        ch.closeFuture().sync();
    } finally {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

Initial load tests without I/O blocking show comparable QPS, with PHP‑Swoole even using far less memory (≈30 MB vs 600 MB for Java). When artificial I/O latency (sleep 0.01 s) is added, the coroutine‑based PHP‑Swoole service achieves roughly six times the QPS of the Java‑Netty service, demonstrating the advantage of effective CPU utilization and coroutine scheduling.

The article concludes that high concurrency is language‑agnostic; once the core goal of “effective CPU squeezing” is understood, any language—PHP, Java, Go—can build high‑performance services by employing connection pools, multi‑threading, coroutines, select/poll, or epoll mechanisms.