The update introduces coroutine support for FTP and SSH clients, adds io_uring‑based HTTP server capabilities, expands RemoteObject and PDO drivers, fixes critical bugs in HTTP2, process handling, and memory management, and includes performance optimizations and important compatibility notes.
This article explains how to use PHP asynchronous coroutines with Swoole and PHPMailer to concurrently send large volumes of emails, improving performance, stability, and resource usage compared to traditional synchronous mailing methods.
This article examines PHP 8.5’s runtime and JIT improvements, compares its async and API throughput with Node.js, and explains how architecture choices like Swoole, RoadRunner, or Octane influence real‑world performance more than the version number itself.
PHP 8.5 introduces a pipe operator that enables fluent, left‑to‑right chaining of string and array functions, replacing deeply nested calls with readable pipelines, and the article compares this feature with traditional PHP 8.4 code and Swoole 6.1’s method‑chaining syntax, providing concrete examples and output.
This article traces the evolution of PHP request handling from early CGI and mod_php through PHP‑FPM to modern runtimes like Swoole, RoadRunner, and FrankenPHP, explaining their architectures, shared‑memory models, performance gains, and practical migration tips.
Hyperf is a high‑performance, highly flexible PHP coroutine framework built on Swoole that delivers superior speed over traditional PHP‑FPM, offers extensive PSR‑based components, and provides a robust foundation for web services, microservices, distributed systems, and IoT applications.
Version 6.1 of Swoole, built on Swoole v6.1.1 and PHP 8.4.14, introduces dynamic GCC support for Swoole‑CLI, a new random extension, libind2 and libpsl for Curl, upgrades PHP, numerous extensions, libraries, and switches HTTP/3 implementation, while fixing macOS build issues and deprecating ngtcp2.
Learn how Swoole transforms PHP into a high‑performance, asynchronous server by detailing its multi‑process architecture, reactor‑worker‑task model, coroutine‑enabled I/O, and practical code examples for TCP clients, HTTP servers, and file operations, enabling scalable, non‑blocking applications.
ManaPHP is a lightweight, high‑performance PHP framework built on Swoole that supports traditional, resident‑memory, and coroutine modes, offering built‑in console and HTTP components, extensive out‑of‑the‑box features, and easy installation for small‑to‑medium projects.
Over four years, we migrated a legacy PHP monolith to a high‑load microservice using Phalcon and Swoole, detailing the project’s background, design decisions, memory‑management challenges, Kafka integration, performance gains, and deployment tips, proving PHP can rival heavyweight platforms.
EasySwoole 3.x is a resident‑memory, coroutine‑based PHP framework built on Swoole that supports HTTP, WebSocket, TCP/UDP, offers numerous ready‑made components, and provides simple installation and startup steps for building high‑performance API services.
The article examines recent PHP async I/O RFC proposals, explains how they aim to integrate epoll/kqueue and coroutine‑based I/O into PHP, compares PHP's async capabilities with other languages and frameworks, and outlines the future direction of asynchronous support in PHP 9 and beyond.
This article examines PHP-FPM's historical strengths, its growing incompatibilities with containerized and micro‑service architectures, outlines three key bottlenecks, and presents modern alternatives such as Swoole, FrankenPHP, and serverless runtimes that enable higher performance, better resource efficiency, and improved observability.
Traditional PHP memory profilers, designed for synchronous blocking execution, struggle in high‑concurrency async frameworks like Swoole or ReactPHP because execution contexts intermix, memory leaks become ambiguous, and profiling overhead distorts performance, requiring specialized tools, snapshot comparisons, and disciplined coding practices to effectively diagnose issues.
Swoole coroutine leaks are stealthy issues that gradually consume CPU and memory, caused by improper loops, global state pollution, inconsistent environments, and limited debugging tools, but can be mitigated with proper context management, lifecycle control, environment consistency, and proactive monitoring.
This article examines how asynchronous programming revitalizes PHP, detailing its core principles, emerging ecosystem, cloud‑native advantages, performance gains, improved developer experience, industry adoption, and the challenges ahead, forecasting that by 2025 async PHP will reshape modern web development.
This article explains how Swoole introduces a typed array feature to PHP, covering its API, supported type definitions, usage restrictions, type‑checking methods, performance comparison with native arrays, and instructions for building the extension, helping developers achieve stricter type safety in backend code.
This article explains how to improve the speed and stability of bulk email delivery in modern web applications by using PHP asynchronous coroutines, detailing the underlying principles, advantages over synchronous sending, and providing a complete code example with Swoole, PHPMailer, and channel coordination.
This guide explains how to install and use the workbunny/php-orc library, which leverages the Swoole Phpy extension to call Python's PyORC module from PHP, enabling efficient reading, writing, and schema handling of Apache ORC columnar files with practical code examples and troubleshooting tips.
This article examines common misconceptions about PHP performance, compares it with Go using Workerman, Swoole, and other frameworks, and explains why modern PHP frameworks claim high speed while highlighting JSON handling, coroutines, and asynchronous programming in PHP.
This guide explains Webman 5's support for Fiber, Swoole, and Swow coroutine drivers, shows how to install the required packages, configure each worker to use a specific driver, provides complete PHP code examples for Workerman and Webman, demonstrates starting the server, checking its status, and highlights compatibility constraints between Swow and Swoole.
Swoole v6.0.0 introduces multithreaded mode, new thread classes and synchronization primitives, iouring‑based asynchronous file I/O, numerous bug fixes, kernel optimizations, and deprecations, providing developers with enhanced performance, richer APIs, and broader platform compatibility for high‑concurrency PHP applications.
This article explains how to use PHP asynchronous coroutines and Swoole to concurrently send large volumes of email, improving speed, stability, and resource usage, and includes a complete code example with PHPMailer integration.
This course provides an in‑depth exploration of Swoole 5, Hyperf 3, and PHP 8 coroutine frameworks, teaching developers how to leverage coroutines for high‑performance, concurrent PHP applications through practical, step‑by‑step instruction and comprehensive coverage of installation, core principles, and advanced implementation techniques.
This course provides an in‑depth analysis of the new coroutine features in Swoole5, Hyperf3, and PHP8, teaching developers how to leverage coroutines for higher concurrency, improved performance, and efficient PHP backend development through practical, hands‑on examples.
This article explains the blocking‑degradation problem in Webman/Workerman's event‑loop, analyzes why traditional solutions fall short, and introduces the webman‑coroutine plugin that adapts multiple coroutine drivers, rewrites the web server, and provides practical guidance for safe coroutine integration.
This article explains how to improve the speed and stability of bulk email delivery in modern web applications by using PHP asynchronous coroutines with Swoole, providing a detailed code example that leverages PHPMailer, channels, and coroutine management.
This guide explains what Swoole‑Cli is, the operating systems it supports, how to download and install the binary, configure the environment, manage PHP‑FPM, run a simple Swoole HTTP server, and start a Webman application, all with concrete commands and examples.
This course offers an in‑depth exploration of Swoole 5, Hyperf 3, and PHP 8 coroutine features, teaching developers how to harness asynchronous programming to boost concurrency, performance, and efficiency in modern PHP applications through practical, hands‑on examples.
This tutorial explains how to build a real‑time video chat application using PHP with the Swoole WebSocket extension and WebRTC, covering environment setup, server and client code, and steps to run the system.
This guide explains what Swoole is, provides step‑by‑step installation and configuration instructions for the PHP extension, shows how to enable it in the Webman framework, and demonstrates coroutine concepts with practical PHP code examples and expected output.
This article explains Swoole, a C extension for PHP that adds asynchronous I/O, multi‑process and coroutine support, outlines its advantages over traditional PHP, and provides a step‑by‑step guide with code to build a basic high‑performance HTTP server.
This article explains how to boost PHP application performance by installing the Swoole extension and using its coroutine API to run concurrent tasks such as HTTP requests and database queries, providing code examples and configuration steps for effective backend concurrency.
This article explains how the Swoole PHP extension can boost website speed through asynchronous and parallel processing, describes its request‑handling lifecycle and server components, and provides step‑by‑step instructions for installing and configuring Swoole with Laravel Octane.
This tutorial introduces Swoole, a powerful PHP extension for event‑driven, non‑blocking programming, guiding readers through prerequisites, environment setup, event‑loop concepts, building a simple asynchronous HTTP server, and performance comparison with traditional synchronous scripts, demonstrating how to create high‑performance backend applications.
This article explains how to implement encapsulated concurrent programming in PHP by using the pcntl extension for multi‑processes, the pthread extension for multi‑threads, and the Swoole extension for coroutines, providing clear code examples and discussing the advantages of each approach.
This article explains the challenges of traditional single-node data storage, introduces microservice architecture, and provides step-by-step PHP Swoole code examples for creating storage and retrieval microservices and a client script, demonstrating how to achieve scalable, fault‑tolerant distributed data storage and retrieval.
This article explains the core principles of microservice architecture and demonstrates how to build a PHP‑based microservice system using Swoole, Lumen, RabbitMQ, and Consul, providing step‑by‑step code examples for installation, routing, and server setup.
This article provides a comprehensive overview of the Swoft microservice framework, detailing its high‑performance architecture, core features such as annotation routing and AOP, step‑by‑step installation, and benchmark results that demonstrate its superiority over Laravel in handling concurrent requests.
This tutorial demonstrates how to combine Swoole's high‑performance PHP WebSocket server with WebRTC's browser‑based real‑time audio/video capabilities, covering server setup, client media capture, video segmentation with FFmpeg, and complete code examples to build a functional live‑streaming application.
This article explains PHP 8.0 Fibers as lightweight coroutines, why they improve high‑concurrency performance, and provides step‑by‑step Swoole‑based code examples for creating connection pools and managing asynchronous tasks in backend applications.
This tutorial explains how to create a live audio/video streaming application by combining WebRTC for browser‑based media capture with a high‑performance Swoole WebSocket server, including code examples, video segmentation with FFmpeg, and a reference to a detailed course.
This guide introduces Swoole, a high‑performance asynchronous PHP framework for IoT, and walks through installing the extension, building TCP and WebSocket servers, performing asynchronous file I/O, and leveraging coroutines with complete code examples.
This article demonstrates how to combine Swoole's high‑performance WebSocket server with WebRTC to create a real‑time audio/video live streaming application, covering server setup, client media capture, video segmenting with FFmpeg, and providing complete code examples for each step.
This article explains the underlying principles of Swoole coroutines, compares them with Go's goroutine model, outlines important usage considerations, contrasts Swoole with Workerman, describes coroutine communication methods, and provides practical PHP performance optimization tips.
This article explains why traditional crontab cannot meet second‑ or millisecond‑level scheduling requirements in PHP projects and demonstrates how to use Workerman and Swoole timers, including code examples for one‑time, recurring, and task‑based executions.
This tutorial walks through installing LaravelS with Swoole using Laradock, configuring Nginx and Docker, adjusting PHP versions, running AB performance tests, and shows that the request‑per‑second results are comparable to a standard Laravel 9 setup.
This article chronicles Bilibili Live's eight‑year journey from a simple LAMP monolith to a sophisticated microservice architecture, detailing the migration to Swoole‑based services, Docker containerization, Golang adoption, hot‑key handling, request amplification mitigation, and the creation of a high‑performance Envoy‑based gateway.
This article chronicles Bilibili Live’s eight‑year journey from a simple LAMP monolith to a highly available microservice ecosystem, detailing the technical motivations, design principles, Swoole‑based services, containerization, Golang migration, custom gateways, hot‑key handling, and operational safeguards that enabled millions of concurrent viewers.
This tutorial explains how to improve high‑concurrency order processing by aggregating requests and using batch inserts with Swoole coroutines in PHP, illustrating the concept with elevator‑like logic and a complete code example.
The article explains the core idea of pooling to trade space for time, analyzes the shortcomings of in‑process connection pools in PHP‑FPM, proposes long‑connection and cross‑process pooling solutions using Swoole’s IPC mechanisms, and demonstrates significant CPU and latency improvements in a real‑world high‑concurrency backend.
This guide introduces Hyperf, a high‑performance PHP coroutine framework built on Swoole, explains its CLI vs PHP‑FPM modes, lists required system extensions, shows how to configure Composer mirrors, install the skeleton, disable Swoole short names, start the server, and resolve common port‑conflict issues.
This tutorial demonstrates how to create a lightweight chatroom by combining WebSocket on the front end with Swoole's WebSocket server in PHP, covering project setup, required environment, client‑side HTML/JS, server‑side PHP code, and steps to run and test the application.
This article introduces Swoole as a high‑performance asynchronous PHP engine, explains its differences from traditional PHP execution, and provides step‑by‑step guidance on integrating Swoole with ThinkPHP5, including a complete code example and key implementation notes.
This article explains what Laravel‑s is, why it was needed to handle high‑traffic Baidu crawler loads, the measurable performance improvements achieved after integration, and provides step‑by‑step deployment and configuration guidance for Laravel projects using Swoole.
The article presents Fend, an open‑source high‑performance PHP framework released by TAL Education's technology team, detailing its design philosophy, feature set, dual FPM/Swoole engine support, performance benchmarks, installation procedures for multiple versions, and its widespread adoption across the company's online services.
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 the fundamentals of Swoole coroutines, how they differ from threads and processes, the relationship between coroutines and asynchronous I/O, and provides practical code examples for timers, tasks, and concurrent DNS queries to help PHP developers write efficient, non‑blocking backend applications.
This article presents a comprehensive case study on how the 58 rental platform refactored its services and optimized performance by splitting common modules, adopting async interfaces, leveraging nginx + swoole, implementing data caching and pre‑loading, resulting in significant reductions in page rendering time and service latency across major app pages.
This guide explains how to use Swoole\Lock in PHP, covering the five supported lock types, constructor parameters, key methods such as lock, unlock, trylock, lockwait, and lock_read, along with best‑practice warnings and a complete example demonstrating inter‑process synchronization.
This article introduces Swoole's Coroutine Channel for inter‑coroutine communication, explains its memory‑efficient implementation and key methods such as __construct, push, pop, stats, close, length, isEmpty, isFull, capacity and errCode, and provides a complete PHP example demonstrating producer‑consumer behavior.
Because PHP lacks native multithreading, Swoole adopts a multi‑process model and provides the Atomic class for lock‑free integer operations, which can be shared across worker processes; this guide explains its purpose, configuration, usage patterns, code examples, and important pitfalls.
This article explains how Swoole's multi‑process model isolates memory in PHP, recommends external storage such as Redis or shared memory via Swoole/Table, details capacity calculations, handling of oversized strings, and provides a complete PHP example demonstrating table creation, data storage, and server communication.
This article demonstrates how Swoole 4’s new coroutine kernel enables fully synchronous‑style PHP code to perform asynchronous I/O, file operations, database queries, and TCP/UDP networking within a single process, showcasing massive performance gains through practical code examples.
This article demonstrates how to build a high‑performance asynchronous TCP server using the Swoole extension in PHP, covering server creation, event callbacks for connection, data reception, and closure, as well as testing the server with telnet or netcat.
This article provides a detailed guide to Swoole's millisecond‑precision timer API, covering the underlying epoll_wait/setitimer implementation, the static methods tick(), after(), clear() and additional utilities such as clearAll(), info(), list(), stats() and set(), with full syntax, usage examples and code snippets for both synchronous and asynchronous processes.
This guide explains how to configure Swoole’s task worker pool, set the required onTask and onFinish callbacks, and use the non‑blocking task() method to dispatch long‑running operations without slowing down the server, complete with a full PHP example.
This tutorial demonstrates how to build a WebSocket server using PHP's Swoole extension and a corresponding HTML/JavaScript client, covering protocol basics, server-side event handling for connections, messages, and closures, and showing the complete code and execution results for real‑time bidirectional communication.
This article introduces Swoole, a production‑grade asynchronous network engine for PHP, outlines the required prerequisites, shows a quick PECL installation, explains how to enable the extension in php.ini, and provides a complete example of building and testing a simple HTTP server.
This article introduces the FastCGI protocol, explains Swoole's task processes, demonstrates how to use the coroutine FastCGI client to invoke PHP‑FPM scripts and concurrently handle blocking calls, and shows a one‑click WordPress proxy implementation with performance benchmarks.
This article explains WebRTC fundamentals, key APIs, and demonstrates how to build a browser‑based peer‑to‑peer video chat by implementing a lightweight signaling server in PHP using Swoole coroutines, complete with client‑side JavaScript code, server logic, and deployment tips.
This article analyzes the performance bottleneck in Swoole 4.5 where the master process copies data twice before delivering it to worker processes, explains the underlying C functions and data flow, and presents two code‑level optimizations that consolidate buffers and eliminate redundant copies, resulting in a four‑fold speedup of the onMessage callback.
This article explains the concept and history of coroutines, surveys language support, and provides an in‑depth analysis of Swoole’s coroutine implementations from version 1.x to 4.x, including PHP Zend VM integration, C‑stack management with assembly, and practical code examples.
This article provides a comprehensive overview of Swoole, covering its basic concepts, TCP server implementation, base and process modes, inter‑process communication mechanisms, reactor‑worker interaction, and debugging techniques for building high‑performance PHP network services.
This article provides a comprehensive technical overview of Swoole's coroutine implementation in PHP 7.1, detailing C‑stack and PHP‑stack management, context switching via boost.context, coroutine creation, scheduling, and I/O event handling, supplemented with diagrams and code excerpts.
This article examines PHP's enduring market share, highlights its practical design and powerful standard library, and outlines six key recommendations—including Composer, PHP 7, PSR standards, Swoole, Laravel, and Phar packaging—to help developers stay competitive in the evolving backend landscape.
The article examines why PHP is often labeled the worst mainstream language, highlighting its chaotic function naming, inconsistent APIs, lack of async I/O and multithreading, historical design flaws, community attitudes, and recent improvements like PHP 7, while acknowledging its early deployment advantages.
This article outlines ten practical recommendations for PHP developers—from mastering Composer and PHP 7 performance gains to adopting modern tools like Swoole, Laravel, and Vue.js—to stay competitive in a rapidly evolving web backend landscape.
This guide explains how to create a full-featured init script for a Swoole‑based mail service, enabling start, stop, restart, reload, and status commands, plus automatic boot‑time activation, with complete shell code and step‑by‑step instructions.
This article explains how Swoole's heartbeat feature works, why it is needed to detect dead TCP connections, and provides configuration tips for reliable asynchronous PHP server management.
A benchmark using ApacheBench compares Nginx static serving, a Golang HTTP server, and a PHP7+Swoole server under 100‑concurrent connections for one million requests, showing PHP7+Swoole achieving roughly 75 % higher QPS than both Nginx and Golang, along with detailed environment, code, and resource usage data.
This article explains how to create an asynchronous MySQL proxy server using the Swoole extension, detailing connection pooling, idle/busy management, request queuing, and providing a complete PHP implementation that reduces MySQL load and network overhead for PHP applications.
The article examines why PHP’s lack of native multithreading isn’t a fatal flaw for high‑concurrency servers when paired with Swoole, compares process‑based and thread‑based models, debunks performance myths, and highlights the productivity benefits of using PHP over C++.
This article examines the PHP7 alpha release, detailing how its revamped Zend engine, memory management, hash handling, and new opcodes dramatically improve execution speed, while also introducing type declarations, exception handling, anonymous classes, and the Swoole extension for asynchronous programming.
Although many claim PHP with Swoole is unsuitable for high‑concurrency servers compared to C++, this article explains how PHP’s process model, Swoole’s Table and Atomic features, and careful design can achieve comparable performance while offering faster development, and discusses the trade‑offs of multithreading versus multiprocessing.
