An interview‑focused analysis explains how processes allocate resources, threads handle CPU scheduling, and coroutines act as lightweight user‑mode threads, comparing their creation costs, switching overhead, and memory usage, and highlights Java 19/21 virtual threads as the Java implementation of coroutines.
This article explains the definitions, internal structures, lifecycle, scheduling, communication mechanisms, and trade‑offs of processes, threads, and coroutines, helping readers master a frequent interview topic and choose the right concurrency model for their applications.
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 explains how to implement low‑level thread pools and coroutines in PHP, providing complete code examples, step‑by‑step usage, and explanations of how they improve concurrency and throughput.
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.
This article walks through serial file reading, thread‑based parallelism, event‑driven asynchronous I/O, callbacks, and finally shows how coroutines combined with an event loop provide a synchronous‑style solution that scales efficiently without the drawbacks of massive threading.
This article explains how to implement low‑level thread pools and coroutines in PHP, detailing their concepts, providing complete code samples, and showing how they improve concurrency and overall application performance.
Although Python’s async/await syntax lets you pause and resume functions, it alone doesn’t run tasks concurrently; you must explicitly schedule coroutines with tools like asyncio.create_task(), gather(), or TaskGroup, and understand when to use sequential versus concurrent execution to avoid common pitfalls.
This article explains the fundamental differences between coroutines and fibers in modern PHP, covering their concepts, implementation layers, scheduling, stack management, integration, and practical code examples, helping developers choose the right concurrency approach for high‑performance applications.
The article explains how early thread‑blocking models led to the invention of callbacks, why deeply nested callbacks create "callback hell," and how promises/futures and their chaining, as well as coroutines, provide more linear and efficient asynchronous programming for high‑concurrency backend services.
The latest Swow release brings complete PHP 8.4 compatibility, introduces a powerful pipe API (Swow\pipe(), Swow\fileno(), Swow\pipe_from_fd()), adds CPU core detection via Swow\nproc(), enhances SSL/TLS reliability, restructures closure serialization, fixes numerous memory‑safety and compatibility bugs, and updates internal libraries.
This comprehensive guide explores Go 1.23's iterator system, detailing the underlying principles of push and pull iterators, code transformations performed by the compiler, coroutine implementation, and practical examples that compare Go's approach with Python and JavaScript, helping developers master iterator usage and design.
This article explains what coroutines are in an RTOS, describes their three states, provides step‑by‑step C code examples for creating and scheduling coroutines, and compares their resource usage, scheduling, and performance with traditional RTOS tasks, highlighting advantages and limitations.
This article explains how Kotlin coroutine cancellation works, why catching CancellationException can create zombie coroutines, and provides concrete patterns—using isActive, coroutineContext.ensureActive(), and proper try‑catch placement—to reliably stop repeating tasks without resource leaks.
This article introduces Hypervel, a Laravel‑style PHP framework with native coroutine support, explains its advantages over Laravel Octane for I/O‑intensive workloads, and presents benchmark results that demonstrate dramatically higher request‑per‑second rates in both simple API and simulated I/O scenarios.
This comprehensive guide explores how coroutines provide a lightweight, lock‑free alternative to traditional threads for high‑concurrency C/C++ server programming, covering their fundamentals, differences from threads, implementation techniques, context switching, scheduler design, epoll integration, timer management, and performance testing.
This article details Bilibili's practical experience with Kotlin Multiplatform (KMP), covering the choice of Bazel as a build system, multi‑language interop, dependency injection, modular export, state‑machine driven single‑direction data flow, and the successful deployment of shared logic and UI across Android, iOS, and HarmonyOS platforms.
This article explains the fundamentals of Python coroutines and the asyncio library, covering basic concepts, key components, practical examples, advanced techniques such as mixing with threads, cancellation handling, performance optimizations, and common troubleshooting tips for asynchronous programming.
This article explains how to use PHP asynchronous coroutines, powered by Swoole, to concurrently send large volumes of email, improving throughput and stability, and provides a complete code example with PHPMailer integration and channel-based task distribution.
This article explains the async def syntax introduced in Python 3.5, its role in defining coroutine functions, when to use it, and provides a detailed example with code walkthrough to illustrate asynchronous I/O handling with asyncio.
This article explains the main concurrency scheduling models—including user‑level, kernel‑level, two‑level (M:N), and coroutine approaches—covers common scheduling algorithms, and details Go’s unique M:P:G scheduler, highlighting its principles, workflow, and advantages for high‑performance parallel execution.
This guide explains Python asynchronous programming using the asyncio library, covering async functions, coroutine objects, the event loop, await syntax, task creation, and concurrent execution with asyncio.run, create_task, and gather to improve I/O‑bound performance.
The article explains workerman v5’s major updates—including a revolt/event-loop based engine and multi‑implementation coroutine support—while detailing PHP coroutine concepts, practical async export examples, code snippets, and the future challenges of expanding coroutine ecosystems in PHP.
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 guide explains how to install the webman-coroutine plugin, set up the Swow extension, configure Webman for coroutine event loops, and use utility classes such as Pool, Channel, and WaitGroup to build a dynamic Redis connection pool with example code and test results.
This article introduces Python's async and await keywords, explains how they enable coroutine programming, and provides multiple practical examples including simple coroutine definitions, awaiting tasks, concurrent execution with asyncio.gather, HTTP requests using aiohttp, and resource management with custom coroutine-based managers.
This tutorial explains what Swow is, walks through installing Workerman 5.0 and the Swow extension via Composer, shows how to run the Swow builder, configure Webman to use Swow's event loop, and demonstrates basic coroutine usage and debugging in PHP.
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.
The article explains what memory leaks are, common causes, and presents practical techniques such as avoiding heap allocations, using smart pointers, employing arena allocators, leveraging coroutines, applying RAII, and debugging with tools like gperftools to detect and resolve leaks in C++ programs.
PRipple is a high‑performance native PHP coroutine framework built on PHP 8.1 fibers and the Revolt library, offering simple APIs for asynchronous I/O, seamless integration with popular PHP frameworks, and easy installation via Composer for developing concurrent, high‑load applications.
This article introduces Python coroutines, compares them with multithreading, explains when to use them, and demonstrates how the httpx library can perform asynchronous HTTP requests to dramatically improve backend performance, including installation steps and a benchmark against synchronous requests.
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 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 revisits a 2017 decision to ban exceptions in a large codebase, examines the technical and organizational reasons behind that rule, analyzes exception mechanics, coroutine interactions, and performance impacts with concrete C++ examples, and finally proposes a pragmatic action plan for safely adopting exception‑driven design.
This article explains the concept of coroutines as lightweight user‑level threads, compares them with traditional threads, details various implementation mechanisms in C/C++ (including libco and NtyCo), and demonstrates how they improve I/O‑bound server performance through examples and code snippets.
This article explains how to implement low‑level thread pools and coroutine mechanisms in PHP, providing detailed code examples that demonstrate creating a ThreadPool class, managing worker threads, and using generator‑based coroutines to achieve high‑performance, concurrent execution.
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 introduces Python coroutines as a lightweight concurrency model and provides ten practical code examples demonstrating how to use the asyncio, gevent, and trio libraries for asynchronous I/O, concurrent network requests, file operations, task scheduling, and more.
This article explains what coroutines are, how they differ from ordinary functions by supporting multiple pause points, demonstrates their behavior with Python code and visual diagrams, covers their historical origins, and details low‑level implementation using stack frames and heap allocation for efficient user‑level concurrency.
This article explains how a Go hello‑world program starts, tracing the ELF entry point, runtime initialization, GMP scheduler setup, creation of the main goroutine, and the flow into the user's main function.
This article explains how to implement a high‑performance Go coroutine pool by adapting key features of Java’s ThreadPoolExecutor, covering core parameters, task queue design, dynamic scaling, worker management, timeout handling, and provides complete code examples and self‑test results.
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.
The article introduces coroutine fundamentals and classifications, then explains how the Tars C++ framework (v3.0.0) implements stackful, symmetric coroutines using Boost.Context for user‑mode context switching and an epoll‑driven scheduler that manages coroutine lifecycles, states, and operations such as go, yield, sleep, and put.
By manually modifying a few hundred lines and using an automated script, we transformed the multithreaded RocksDB storage engine into a coroutine‑based version with PhotonLibOS, achieving near‑identical functionality and, in heavy I/O and high‑concurrency scenarios, up to double the throughput compared to the original.
KeeWiDB, a next‑generation distributed KV store from Tencent Cloud, combines a proxy layer, multi‑node service layer, tiered hot‑cold data placement, multi‑threaded and coroutine‑based processing, persistent memory caching, direct I/O, and enhanced replication to address Redis’s memory cost, scalability, and latency challenges.
This article compares the legacy C++17 stackless coroutine implementation using macro‑generated state machines with the native C++20 coroutine model, explains their core concepts, and demonstrates how to design a flexible scheduler that manages various await modes and integrates custom awaitable tasks.
C++20 coroutines turn functions containing co_await, co_yield, or co_return into suspendable tasks, requiring a promise_type that defines get_return_object, initial_suspend, final_suspend, yield_value, return handling, and exception management, while handles manage resumption, and custom awaiters enable asynchronous I/O such as non‑blocking TCP connections.
The article explains how Asio implements C++20 coroutine support by converting callback‑based async operations into awaitables with use_awaitable, launching them via co_spawn and co_spawn_entry_point, handling result propagation and thread dispatch, and providing parallel composition operators (&&, ||) for concurrent awaiting.
The article analyzes the high load and low CPU utilization problems of a Java service, compares various I/O models, introduces coroutine fundamentals and the Quasar library, demonstrates practical migration steps with code examples, and evaluates the performance gains and risks of adopting coroutine‑based concurrency.
This article explains how to achieve high‑performance C10M concurrency by moving memory management, packet handling, and scheduling out of the kernel into user space, introduces coroutine concepts, demonstrates a producer‑consumer coroutine example, discusses coroutine stack implementations (stackful vs stackless), and outlines classic scheduling strategies.
The article explains how C++20 coroutines and the emerging execution framework are used to redesign a single‑threaded game‑server architecture, detailing custom async wrappers, integration with asio and libunifex, job‑type scheduling, example coroutine code, current limitations, and a roadmap toward a simpler, sender/receiver‑based async library.
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.
This article provides a step‑by‑step technical guide to implementing C++ stackful coroutines, covering the design of the owl.context API, low‑level context‑switch principles, register saving conventions on 32‑bit ARM, and complete source code for co_getcontext, co_setcontext, co_swapcontext and co_makecontext with illustrative examples and diagrams.
This article traces the historical origins of coroutines from early COBOL compiler challenges, explains their cooperative execution model, compares them with thread scheduling, and reviews how modern languages like Python, C++ and Go implement coroutine support to improve IO‑bound performance.
This tutorial explains Python's iteration concepts, how to identify and create iterable objects, implement custom iterables and iterators, use the iter() and next() functions, build generators with yield, control execution with coroutines, and leverage greenlet and gevent for cooperative multitasking.
This article explains the low‑level principles of C++ coroutine context switching, walks through the owl.context API design, demonstrates assembly implementations for co_getcontext, co_setcontext, co_swapcontext and co_makecontext, and provides practical examples and code to build stackful coroutines on 32‑bit ARM.
This article explains the motivation behind creating the C++ coroutine framework "owl" for the cross‑platform WeChat client, compares callback, promise, and coroutine approaches with code examples, and details its design choices such as stackful coroutines, single‑thread scheduling, structured concurrency, and performance characteristics.
This article compares the evolution of coroutines in Python and JavaScript, explaining their shared goals, core concepts, historical milestones, mature implementations, and practical code examples to help newcomers understand asynchronous programming across both languages.
The article walks through C++20 coroutines—from basic suspension mechanics and the roles of coroutine_handle, promise_type, and awaitable methods—to constructing a lightweight game scheduler that manages task lifetimes, await modes, and RPC integration, and demonstrates how this approach mirrors Python’s yield‑based skill system while offering clearer, high‑performance native code.
This article shares a developer’s experience converting a Java Spring Boot microservice to Kotlin, covering why Kotlin is attractive, required Maven plugins and dependencies, code‑migration quirks such as open classes and @Jvm annotations, testing hurdles, and the final decision to revert to Java.
This article compares the evolution, concepts, and practical implementations of coroutines in Python and JavaScript, explaining their histories, core mechanisms such as async/await, event loops, and providing side‑by‑side code examples to help newcomers understand asynchronous programming in both languages.
This article explains what coroutines are, compares Python's coroutine implementation with Go's goroutine model, discusses their execution characteristics, and provides code examples illustrating producer‑consumer pipelines and async/await usage in both languages.
This article explains Python's asyncio asynchronous I/O model, how to define and run coroutines, use callbacks, manage multiple concurrent tasks with gather, compare run_until_complete with run_forever, and properly close the event loop, providing clear code examples throughout.
This document outlines the latest release of the C++ coroutine library “co”, providing GitHub links, reference documentation, new features such as xrepo, vcpkg integration, defer, channel, waitgroup, scheduler APIs, API changes, and several bug fixes.
This article explains what coroutines are, compares them with threads, outlines when to use them, introduces the async‑capable httpx library, shows installation and sample code, and demonstrates a performance test where asynchronous requests cut execution time by about 73% compared to synchronous requests.
This article explains the concept of Python coroutines, compares them with multithreading, outlines suitable and unsuitable scenarios, introduces the httpx library for asynchronous HTTP calls, and demonstrates performance gains through synchronous and asynchronous code examples.
This article explains how Python implements coroutines for high‑performance network and web programming by combining OS‑level IO multiplexing, generator‑based control flow, callback elimination, stack‑driven call‑chain traversal, Future objects, and the evolution toward async/await syntax.
libtask, a lightweight coroutine library written by Russ Cox, demonstrates how to build a cooperative multitasking scheduler in C, detailing task creation, context switching, epoll‑based I/O handling, and a non‑preemptive FIFO scheduling model that enables asynchronous I/O to appear synchronous for server development.
This article explains Python coroutines, their advantages over threads, demonstrates producer‑consumer patterns, introduces the asyncio event loop, shows how to use async/await syntax, and provides examples of asynchronous network requests and a simple aiohttp server for high‑concurrency I/O.
This article presents a PHP coroutine‑based Task Scheduler that enables high‑concurrency RPC calls and asynchronous MySQL queries, explains its design and implementation with code examples, compares performance against traditional synchronous and HttpMultiClient approaches, and discusses task dependency handling using DAG and topological sorting.
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.
Version 1.0.3 of the pure PHP coroutine Wind Framework introduces a new Chan class for intra-process coroutine messaging, enhances the message queue with Redis and Beanstalk drivers supporting massive consumer counts and timeout settings, and fixes several Beanstalk client command errors.
This article explains the concept of coroutines, compares them with ordinary functions, shows Python code examples of yielding and resuming execution, illustrates their historical background, and describes how they are implemented using heap‑allocated stack frames to achieve lightweight, user‑level concurrency.
A whimsical story depicts a GoLang envoy introducing the concept of coroutines to the proud Java empire, contrasting thread blocking, asynchronous callbacks, and cooperative scheduling, and explores how execution contexts can be saved, switched, and resumed without OS intervention.
Coroutines, also known as micro‑threads, allow a single thread to pause and resume functions, offering higher efficiency than traditional multithreading by eliminating context‑switch overhead and lock contention, with Python’s generator‑based implementation enabling lock‑free producer‑consumer patterns and seamless multi‑core utilization via processes.
This article explains the operating‑system concepts of processes, threads, and coroutines, compares their performance with Python code examples, discusses the impact of the GIL and DMA, and provides clear guidelines for choosing the right concurrency model based on CPU‑bound, I/O‑bound, or mixed workloads.
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.
Using iQiyi’s open‑source libfiber as a case study, the article explains how network coroutines combine sequential programming simplicity with non‑blocking I/O scalability, detailing libfiber’s single‑threaded scheduler, cross‑platform event engine, coroutine‑aware synchronization, API hooking, and its deployment in high‑performance CDN caching and DNS services.
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.
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 presents the design, reconstruction, and deployment of an asynchronous, event‑driven PHP microservice framework built on Swoole, detailing its background, technical objectives, serialization, RPC architecture, coroutine handling, service governance, and performance improvements for high‑concurrency rental‑business applications.
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 Python coroutine fundamentals, async/await syntax, and demonstrates how to use aiohttp with an event loop and semaphore to dramatically speed up I/O‑bound network requests, providing practical code and performance results.
This article walks through the evolution of Python's coroutine support—from early generator‑based yield/send patterns, through the introduction of @asyncio.coroutine and yield from, to the modern async and await syntax—explaining concepts, execution flow, and providing clear code examples.
This article explains how Python's asyncio library enables asynchronous programming by defining coroutine functions with async/await, managing execution with an event loop, coordinating multiple tasks using gather, wait, and ensure_future, and integrating synchronous code via executors for concurrent execution.
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 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.
Alibaba’s newly open‑sourced coobjc framework brings coroutine‑based async/await, generators, and actor model support to Objective‑C and Swift on iOS, offering cleaner code, better performance, and reduced threading issues compared to traditional block‑based GCD approaches, with detailed design, implementation, and benchmark insights.
This article explains the concept of coroutines, compares them with threads, outlines their pros and cons, and demonstrates multiple Python implementations using yield, send, and decorators, culminating in a practical generator‑based file‑search utility that mimics the Linux grep command.
This article explains the fundamentals of asynchronous programming, contrasting blocking, non‑blocking, synchronous and asynchronous execution, and demonstrates how to implement async behavior in Python using Tornado, asyncio, and aiohttp, including coroutine definitions, yield usage, and practical code examples.
This article introduces Python's asyncio library, explains how coroutines are defined and run, demonstrates event‑loop management with run_until_complete and run_forever, covers callbacks, gathering multiple coroutines, and best practices for closing loops, all illustrated with clear code screenshots.
This article provides a detailed examination of Tornado’s IOLoop core, explaining its callback handling, timer management, I/O event loop, and the pivotal role of Future objects, while also demystifying the implementation of gen.coroutine and offering practical code examples to illustrate asynchronous execution.
This article explains the concept of coroutines, compares them with threads, outlines their advantages and drawbacks, demonstrates how to implement them in Python using yield, next, send and decorators, and applies them to build a grep‑like file‑search utility.
This article explains Python's inter-process communication methods, including process creation, queues, pipes, locks, and pools, and introduces coroutines as lightweight alternatives, detailing their creation with gevent, practical web crawling, and socket server implementations, highlighting performance benefits and appropriate use cases.
This article explains the inner workings of Tornado's IOLoop, covering its three core components—callback handling, timeout scheduling, and I/O event processing—while also detailing the Future class and the gen.coroutine implementation that together enable asynchronous programming in Python.
This tutorial explains what coroutines are, compares their pros and cons, shows how to implement them in Python with yield, next() and send(), and demonstrates a practical file‑search utility built with procedural programming and generators.
