Tagged articles
Asynchronous Programming
94 articles · Page 1 of 1
This article explains how Spring's built-in event mechanism provides a lightweight alternative to message queues for in-process asynchronous decoupling, covering synchronous vs asynchronous handling, transactional event listeners, thread pool configuration, lifecycle events, and when persistent solutions are needed.
Application Lifecycle EventsAsynchronous ProgrammingIn-Process Decoupling
0 likes · 7 min read

This article explores eight ways to implement asynchronous programming in Java, including Thread, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, Hutool ThreadUtil, and Guava ListenableFuture, with code examples and trade-offs for each approach.
Asynchronous ProgrammingCompletableFutureFuture
0 likes · 14 min read

This article analyzes Netty's custom Future system, contrasting CompleteFuture (pre-completed results) with JDK's CompletableFuture (composable async tasks), and explains six architectural reasons Netty retains its own Future—including EventLoop thread binding, deadlock detection, lightweight completed futures, Channel binding, and ecosystem compatibility—with a deep dive into DefaultPromise's CAS-based implementation.
Asynchronous ProgrammingCompletableFutureCompleteFuture
0 likes · 27 min read

With Java 21's cheap virtual threads, many of the blocking‑IO patterns that forced developers to write CompletableFuture callback chains can now be expressed as straightforward synchronous code, yet CompletableFuture still offers powerful task‑orchestration features that virtual threads alone cannot replace.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 9 min read

The article explains how, at the ten‑million‑QPS scale, the hidden cost of thread‑bound synchronous calls—memory, scheduling overhead, and stability risks—explodes, making asynchronous architectures essential, and outlines the trade‑offs, gradual migration paths, and scenarios where async should or should not be applied.
Asynchronous Programminghigh concurrencyperformance optimization
0 likes · 19 min read

The article examines eight practical ways to implement asynchronous programming—thread pools, CompletableFuture, Spring @Async, message queues, event‑driven architecture, reactive streams, the Actor model, and coroutines/virtual threads—explaining their core mechanisms, trade‑offs, production‑grade configurations, and when each should be chosen.
Asynchronous ProgrammingConcurrencyJava
0 likes · 53 min read

This article explains why CompletableFuture replaces traditional Future in high‑concurrency Java applications, demonstrates core APIs such as runAsync, supplyAsync, thenApply, allOf, anyOf, thenCombine, and exception handling, and provides detailed code examples—including serial, parallel, aggregation, and an e‑commerce order‑processing case—to guide robust asynchronous programming.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 26 min read

This article explains why synchronous Python code blocks on I/O, introduces asyncio’s event loop and coroutine model, and walks through creating and managing tasks, using TaskGroup, handling timeouts, avoiding common pitfalls, and applying best‑practice patterns for high‑performance I/O‑bound programs.
Asynchronous ProgrammingConcurrencyPython
0 likes · 20 min read

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.
Asynchronous ProgrammingReactor Patterncoroutine
0 likes · 13 min read

This article introduces CompletableFuture, explains its core features and ideal use cases, and provides 50 practical Spring Boot 3 examples covering simple async tasks, chaining, exception handling, timeouts, custom thread pools, HTTP requests, and advanced composition techniques.
Asynchronous ProgrammingCompletableFutureJava
0 likes · 15 min read

This comprehensive guide walks you through Python's evolution from simple generators using yield, through two‑way communication with yield expressions and generator delegation with yield from, to modern asynchronous programming with asyncio and async/await, including practical examples, performance comparisons, best practices, and common pitfalls.
Async/AwaitAsynchronous ProgrammingPython
0 likes · 17 min read

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.
Asynchronous ProgrammingPromisescallback hell
0 likes · 6 min read

This article explains why asynchronous execution shortens request latency and presents eight practical Java techniques—including raw threads, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, ThreadUtil, and Guava ListenableFuture—complete with code examples and usage tips.
Asynchronous ProgrammingCompletableFutureFuture
0 likes · 13 min read

The article traces the evolution from blocking thread‑based synchronous code to callback‑driven asynchronous patterns, exposes the pitfalls of callback hell, and shows how promises/futures and their chainable API offer a cleaner, more efficient way to handle high‑concurrency backend operations.
Asynchronous ProgrammingPromisescallbacks
0 likes · 6 min read

Learn how to leverage MyBatis-Plus’s type-safe LambdaQueryWrapper together with Spring Boot’s @Async annotation to build efficient, asynchronous database operations, covering basic usage, advanced thread-pool configuration, exception handling, transaction management, and real-world scenarios for backend developers.
Asynchronous ProgrammingLambdaQueryWrapperMyBatis Plus
0 likes · 9 min read

This article compares Kotlin Channel and Flow, explains their design differences, outlines when to prefer each tool, provides step‑by‑step usage instructions, showcases four channel types, presents real‑world Android examples, and covers advanced patterns and exception handling for robust coroutine communication.
AndroidAsynchronous ProgrammingCoroutines
0 likes · 19 min read

This article explains the drawbacks of synchronous C++ code, introduces asynchronous programming concepts, and walks through core C++ async tools such as std::async, std::future, std::promise, and std::packaged_task with practical code examples and performance‑focused case studies.
Asynchronous ProgrammingC++std::async
0 likes · 24 min read

This article explores the significance of C++20, detailing its major new features such as modules and coroutines, explains how they improve compilation speed, code organization, and asynchronous programming, and provides practical examples and migration strategies for modern C++ development.
Asynchronous ProgrammingC++20Coroutines
0 likes · 41 min read

This article explains synchronous versus asynchronous processing through a parcel‑delivery example, outlines core async concepts, presents common async techniques such as message queues, event‑driven design and non‑blocking I/O, and demonstrates practical implementations with Spring Cloud Gateway, Netty, ELK‑Kafka pipelines, and CompletableFuture batch processing.
Asynchronous ProgrammingJava ConcurrencyMessage Queue
0 likes · 17 min read

Promise.allSettled enhances JavaScript concurrency by waiting for every promise to settle—whether fulfilled or rejected—so developers can retrieve all results and handle errors more flexibly, unlike Promise.all which aborts on the first rejection.
Asynchronous ProgrammingJavaScriptPromise.allSettled
0 likes · 4 min read

This article walks through the evolution of JavaScript asynchronous programming—from callback hell to promises and finally async/await—explaining how async/await works, when true synchronous execution is needed, and providing practical techniques and code examples for clean, maintainable async code.
Async/AwaitAsynchronous ProgrammingCode Examples
0 likes · 6 min read

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.
Asynchronous ProgrammingPythonasyncio
0 likes · 9 min read

This article explains the concepts, differences, and practical usage of Java's Future and CompletableFuture for asynchronous programming, highlighting their blocking behavior, task composition, exception handling, and suitable scenarios in performance testing and complex test workflows, with detailed code examples.
Asynchronous ProgrammingCompletableFutureFuture
0 likes · 14 min read

This guide introduces asynchronous Python, explaining why async improves speed, how coroutines and the event loop work, and provides practical examples and common pitfalls to help developers write faster, more efficient I/O‑bound code.
Asynchronous ProgrammingCoroutinesPython
0 likes · 14 min read

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.
Asynchronous ProgrammingConcurrencyPython
0 likes · 5 min read

This article explains why asynchronous programming boosts Java application performance and walks through seven practical methods—Thread, FutureTask, CompletableFuture, Guava ListenableFuture, EA‑Async, Cactoos, and Jcabi‑Aspects—each illustrated with complete, runnable code examples.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 14 min read

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.
Async/AwaitAsynchronous ProgrammingPython
0 likes · 7 min read

This comprehensive guide introduces Java's CompletableFuture, explains its advantages over the traditional Future API, demonstrates how to create and compose asynchronous tasks, manage thread pools, handle timeouts and cancellations, and apply robust exception handling techniques for reliable concurrent programming.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 16 min read

This article explains why C++ timers are essential for asynchronous programming, presents three implementation approaches—including a simple thread‑chrono version, a Boost.Asio based timer, and a C++11 atomic/condition‑variable design—offers practical optimization tips such as precise intervals, thread‑pool reuse, efficient callbacks, and memory management, and demonstrates their impact with a network‑server case study comparing naïve and optimized solutions.
Asynchronous ProgrammingBoost.AsioC++
0 likes · 22 min read

This article explains how to cancel asyncio tasks, invoke sub‑coroutines, cancel sub‑coroutines, handle multiple task cancellations, and manage errors in Python's asynchronous programming, providing clear code examples for each scenario and demonstrating best practices for robust async code.
Asynchronous ProgrammingPythonasyncio
0 likes · 7 min read

This article proposes an asynchronous timeout implementation for CompletableFuture in JDK 8, addressing the lack of built-in timeout interruption capabilities and providing a solution for precise task timeout control.
Asynchronous ProgrammingCompletableFutureJDK 8
0 likes · 10 min read

Java's CompletableFuture, introduced in Java 8, replaces the blocking Future with a rich, non‑blocking API that supports asynchronous task creation, result retrieval via get/join, chaining callbacks, exception handling, task combination (AND/OR, allOf/anyOf), and recommends custom executors, timeouts, and proper saturation policies.
Asynchronous ProgrammingBest PracticesCompletableFuture
0 likes · 16 min read

Ten practical techniques—early validation, batch queries, asynchronous processing, parallel execution, caching, connection pooling, response compression, message‑queue decoupling, security best practices, and reusable design patterns—collectively reduce latency, boost throughput, and improve scalability of high‑concurrency interfaces.
Asynchronous ProgrammingCachingGo
0 likes · 29 min read

This article explains how to build high‑concurrency systems by analyzing single‑machine hardware and code optimizations, clarifying multithreading versus asynchronous methods, and then scaling horizontally and vertically with caching, partitioning, and distributed inventory management to achieve stable, performant services for large‑scale e‑commerce workloads.
Asynchronous ProgrammingMultithreadingRedis
0 likes · 18 min read

This article explores the three‑high requirements of modern internet systems, compares multithreading with asynchronous methods, and presents a practical, partition‑based inventory‑deduction architecture that leverages Redis caching, MySQL sharding, and asynchronous updates to achieve scalable high‑concurrency performance.
Asynchronous ProgrammingMySQLRedis
0 likes · 19 min read

This article explains how to guarantee that when any asynchronous thread fails during a large Excel import, the main thread can roll back all related transactions, covering the limitations of @Transactional and @Async, thread‑local propagation, and practical solutions using Future, CompletableFuture, custom ForkJoinPool, and manual transaction management.
Asynchronous ProgrammingJavaSpring
0 likes · 20 min read

This article analyzes the shortcomings of existing Kotlin coroutine tutorials and presents a step‑by‑step guide to building a lightweight coroutine framework from scratch, covering thread basics, CoroutineScope, launch, delay, resume, state‑machine logic, withContext, async, and Deferred with complete code examples.
Asynchronous ProgrammingCoroutinesCustom Implementation
0 likes · 15 min read

This article explains asynchronous programming concepts for PHP, introduces the lightweight AMPHP library and its coroutine‑based event loop, outlines core technologies, common use cases, installation steps, required PHP version, and provides practical code examples for building non‑blocking, high‑throughput applications.
AmpHPAsynchronous ProgrammingPHP
0 likes · 9 min read

This comprehensive guide explains what callback functions are, their purposes and common use cases, multiple implementation techniques such as function pointers, functors, and lambda expressions, and provides practical C++ examples, advantages, drawbacks, and best‑practice recommendations.
Asynchronous ProgrammingC++callbacks
0 likes · 16 min read

The article breaks down modern asynchronous programming by examining four core models—callbacks, Promises, reactive observer patterns, and message‑driven architectures—explaining their mechanics, pros and cons, and providing JavaScript/Dart examples and system diagrams to help developers master non‑blocking concurrency.
Async/AwaitAsynchronous ProgrammingConcurrency
0 likes · 26 min read

This article explains Java's CompletableFuture, its advantages over the traditional Future API, demonstrates common methods with code examples, and shows how RocketMQ leverages CompletableFuture to coordinate asynchronous disk flush and replica synchronization tasks.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 15 min read

This article explains seven advanced JavaScript async/await patterns—including higher‑order functions, concurrency control, recursive processing, asynchronous class initialization, method chaining, event‑loop integration, and streamlined error handling—to help developers write clearer, more maintainable asynchronous code.
Advanced TechniquesAsync/AwaitAsynchronous Programming
0 likes · 15 min read

This article provides an extensive overview of Python libraries and frameworks for web crawling, HTTP handling, HTML parsing, text processing, asynchronous programming, queue management, cloud execution, WebSocket communication, DNS resolution, computer vision, proxy servers, and popular web frameworks such as Django, Flask, Web2py, Tornado, and CherryPy, helping developers choose appropriate tools for backend development.
Asynchronous Programming
0 likes · 10 min read

This article introduces Python coroutines and asynchronous programming using the asyncio module, explains key concepts such as event loops and non‑blocking I/O, and provides ten detailed code examples that demonstrate creating, managing, and synchronizing async tasks for improved performance.
Asynchronous ProgrammingBackendCoroutines
0 likes · 7 min read

Explore the fundamentals and advanced techniques of asynchronous programming in Java, from basic thread creation and thread pools to Future, FutureTask, CompletableFuture, and Spring Boot’s @Async annotation, including practical code examples, event handling, and message queue integration for high‑throughput systems.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 17 min read

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.
Asynchronous ProgrammingGeventPython
0 likes · 7 min read

The article explains how to dramatically reduce the response time of an API that must call multiple downstream services by converting serial calls into parallel ones using Java 8's CompletableFuture, covering its relationship to Future, core APIs, task composition, exception handling, and practical best‑practice recommendations.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 20 min read

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.
Asynchronous ProgrammingPythoncoroutine
0 likes · 13 min read

This comprehensive guide explains Java's CompletableFuture API, covering its fundamentals, creation methods, chaining operations, exception handling, and best practices for parallel execution, while providing clear code examples and performance tips for building efficient asynchronous workflows in backend development.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 20 min read

This article introduces four methods—manual setting, TaskDecorator, InheritableThreadLocal, and TransmittableThreadLocal—to propagate contextual data such as user information from a parent thread to child threads in Spring Boot asynchronous execution, providing code examples and practical recommendations.
Asynchronous ProgrammingJavaSpring Boot
0 likes · 13 min read

This tutorial explains Java 8's CompletableFuture, showing how to create, compose, and handle asynchronous tasks with methods like supplyAsync, thenApply, allOf, and anyOf, while emphasizing custom thread pools, non‑blocking patterns, and robust exception handling for real‑world concurrent programming.
Asynchronous ProgrammingCompletableFutureException Handling
0 likes · 17 min read

Explore how Java's CompletableFuture enhances asynchronous programming by overcoming Future's limitations, learn its core APIs, practical code examples, and see a real-world application in RocketMQ where combined futures streamline message persistence and replication.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 15 min read

This article explores three Python coroutine libraries - asyncio, gevent, and trio - providing 10 practical code examples demonstrating their use in asynchronous programming for tasks like IO operations, network requests, file handling, and more.
Asynchronous ProgrammingConcurrent ProgrammingCoroutines
0 likes · 5 min read

This article explains the concepts, differences, and implementation approaches of the Observer and Publish‑Subscribe design patterns, and provides ten practical Python code examples covering GUI, networking, asynchronous, and distributed scenarios.
Asynchronous ProgrammingObserver PatternPublish‑Subscribe
0 likes · 11 min read

This article explains why high‑performance concurrent and asynchronous PHP applications are needed, introduces ReactPHP and Amp as non‑blocking I/O libraries, and provides step‑by‑step code examples for creating a simple HTTP server with ReactPHP and performing parallel HTTP requests using both ReactPHP and Amp.
AMPAsynchronous ProgrammingConcurrency
0 likes · 5 min read

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.
Asynchronous ProgrammingC++Tars
0 likes · 13 min read

This article explains why asynchronous execution improves latency in common scenarios like sending SMS or emails, and presents eight Java techniques—including threads, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, third‑party utilities, and Guava—to implement robust asynchronous programming.
Asynchronous ProgrammingCompletableFutureFuture
0 likes · 14 min read

This article demonstrates how to convert multiple asynchronous queries into a synchronous response using Java's CompletableFuture, providing step‑by‑step code examples in both Java and Groovy, explaining execution flow, timeout handling, and practical considerations for WebSocket‑like scenarios.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 5 min read

This article explains the Dart Future object, its role in representing asynchronous task results, how to listen to success and error callbacks with then, catchError, and whenComplete, the special FutureOr type, chaining with then, and simplifying code using async/await, illustrated with Flutter examples.
Asynchronous ProgrammingDartFlutter
0 likes · 19 min read

This comprehensive guide explores Node.js’s architecture, core APIs, global variables, built‑in modules, function styles, the event‑loop mechanics, task scheduling, next‑tick and microtasks, libuv’s role, and strategies for off‑loading work, providing developers with a deep understanding of how Node.js runs JavaScript efficiently.
Asynchronous ProgrammingNode.jsbackend development
0 likes · 23 min read

This article introduces the concept of asynchronous programming in Java, compares it with synchronous execution, and provides detailed examples of five implementation approaches—thread creation, thread pool with Future, CompletableFuture, SpringBoot @Async, and Guava ListenableFuture—complete with code snippets and usage guidelines.
Asynchronous ProgrammingCompletableFutureFuture
0 likes · 9 min read

This article introduces Python's asyncio library, explains the fundamentals of coroutines, tasks, and the event loop, compares synchronous and asynchronous code execution with practical examples, and demonstrates how asynchronous programming can significantly improve performance in I/O‑bound scenarios.
Asynchronous ProgrammingConcurrencyevent-loop
0 likes · 10 min read

This article introduces asynchronous programming concepts in Java, explaining how multithreading, Future, FutureTask, CompletableFuture, and Spring's @Async annotation can transform synchronous workflows into high‑throughput, low‑latency solutions, with code examples and practical guidance for implementing each technique.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 17 min read

The article thoroughly examines libunifex’s structured concurrency implementation, detailing its DSL‑based execution framework and the three core components—Sender Factory, Sender Adapter, and Receiver—through examples like just(), then(), and sync_wait(), and explains how these pieces combine to build asynchronous pipelines.
Async ExecutionAsynchronous ProgrammingC++
0 likes · 14 min read

This article provides a comprehensive analysis of libunifex's core concepts—including Sender, Receiver, TypedSender, OperationState, Scheduler, and Structured Concurrency—explaining how they interact to enable lazy, composable asynchronous operations in modern C++.
Asynchronous ProgrammingC++Sender Receiver
0 likes · 20 min read

This article thoroughly explains libunifex’s sender/receiver model for C++ asynchronous programming, covering its design goals, module structure, pipeline composition, key functions like schedule, then, sync_wait, and the connect/start mechanisms, while demonstrating practical examples and integration with C++20 coroutines and cancellation support.
Asynchronous ProgrammingC++Cancellation
0 likes · 16 min read

The article explains asynchronous programming by contrasting concurrency, parallelism, and synchronization, illustrates how splitting serial work into independent async tasks can improve performance but introduces resource, locking, and state‑tracking challenges, and offers strategies such as careful task limits, locking, queues, and result monitoring.
Asynchronous ProgrammingConcurrencyParallelism
0 likes · 23 min read

This article explains the differences between synchronous and asynchronous execution, explores various I/O programming models—including blocking, non‑blocking, multiplexed, signal‑driven, and asynchronous I/O—and describes how event‑driven architectures apply these concepts in server‑side development.
Asynchronous ProgrammingI/O ModelsPython
0 likes · 12 min read

This article explains the differences between synchronous and asynchronous calls, describes various I/O models—including blocking, non‑blocking, multiplexed, signal‑driven, and asynchronous I/O—and outlines how event‑driven programming works in Python back‑end frameworks such as Tornado, Twisted, Gevent, and asyncio.
Asynchronous ProgrammingI/O ModelsPython
0 likes · 9 min read

This article compares synchronous and various asynchronous approaches for invoking multiple third‑party services in a Spring Boot order‑creation workflow, demonstrating plain sequential calls, manual thread creation, thread‑pool execution, CompletionService handling, and CompletableFuture composition, and shows their performance impact through timing results.
Asynchronous ProgrammingCompletableFutureJava Concurrency
0 likes · 8 min read

This article reviews why asynchronous programming is needed, explains continuations, compares callbacks, promises, reactive streams, async/await, and user‑level threads, and shows how each technique reduces I/O blocking and improves concurrency in Java applications.
Async/AwaitAsynchronous ProgrammingConcurrency
0 likes · 13 min read

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.
Async/AwaitAsynchronous ProgrammingPython
0 likes · 13 min read

This article explains what synchronous and asynchronous Python code mean, how they are implemented in web servers, the performance factors of context switching and scalability, and the specific scenarios where async can outperform sync.
Asynchronous ProgrammingPythonevent-loop
0 likes · 12 min read

This article walks through the evolution of Java asynchronous programming, starting with a simple synchronous HTTP call, examining blocking I/O, exploring JDK NIO and Future, demonstrating callback patterns, addressing callback hell, and showing how CompletableFuture, Vert.x Future, Reactive Streams, and Spring WebFlux provide scalable, non‑blocking solutions.
Asynchronous ProgrammingCompletableFutureJava
0 likes · 10 min read

This article explains the fundamentals of asynchronous programming and multithreading, compares their models with clear examples, discusses callbacks, highlights performance trade‑offs, and offers guidance on choosing the right approach for I/O‑heavy Java applications.
Asynchronous ProgrammingCallbackJava
0 likes · 8 min read

This article uses a single illustrative diagram to explain how .NET's async/await works, detailing thread release during I/O, overlapped I/O via IOCP on Windows, continuation scheduling, and differences on Linux with epoll, highlighting scalability and thread reuse benefits.
.NETAsync/AwaitAsynchronous Programming
0 likes · 6 min read

The article examines JavaScript’s event loop by contrasting macro‑tasks and micro‑tasks, tracing their spec‑defined origins, showing how callbacks, timers, Promises, async/await and generators are queued, and highlighting differences between browsers and Node.js (pre‑v11 vs v11+) that affect execution timing.
Asynchronous ProgrammingBrowser ImplementationCallback Mechanism
0 likes · 12 min read

This article explains how Java's CompletableFuture and CompletionStage APIs enable asynchronous programming without external libraries, providing detailed explanations and 20 code examples that cover creation, chaining, combining, exception handling, cancellation, and execution with custom executors.
Asynchronous ProgrammingBackendCompletableFuture
0 likes · 19 min read

Node.js’s single‑threaded model relies on an asynchronous continuation framework, and this article explains the core concepts—execution frames, continuations, link points, ready points—and how async_hooks, AsyncLocalStorage, and related APIs can be used to trace, debug, and ensure clean async task handling in backend applications.
Asynchronous ProgrammingNode.jsasync_hooks
0 likes · 18 min read

This article introduces the challenges of traditional concurrency, explains the structured concurrency paradigm, surveys its history and implementations across languages, and provides a detailed Rust example using the task_scope library with Scope, CancelScope, timeout handling, nested scopes, and a practical Happy Eyeballs exercise.
Asynchronous ProgrammingCancellationConcurrency
0 likes · 12 min read

This article explains how Alibaba’s Wisp2 brings Go‑like coroutine performance to Java by replacing OS thread scheduling, details its design, shows benchmark improvements over traditional thread‑pool models, compares it with Project Loom, and provides practical code snippets for enabling Wisp2 in production.
Asynchronous ProgrammingConcurrencyCoroutines
0 likes · 16 min read

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.
Async/AwaitAsynchronous ProgrammingPython
0 likes · 10 min read

This article explains how C# thread pools reduce thread‑creation overhead, describes several ways to enqueue work (Task Parallel Library, ThreadPool.QueueUserWorkItem, asynchronous delegates, BackgroundWorker), provides practical code examples, and outlines important considerations such as thread naming, priority, and exception handling.
Asynchronous ProgrammingC++Multithreading
0 likes · 9 min read

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.
Asynchronous Programmingcoobjccoroutine
0 likes · 12 min read

By adopting an event‑driven reactive architecture and leveraging RxJava’s asynchronous, message‑oriented programming, Youzan Retail decouples services, parallelizes complex initialization and data‑transformation tasks, reduces response time and coupling, and enhances robustness, scalability, and throughput for its rapidly growing retail platform.
Asynchronous ProgrammingJavaRxJava
0 likes · 11 min read

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.
Asynchronous ProgrammingConcurrencyasyncio
0 likes · 7 min read

This article explains the differences between synchronous, asynchronous, blocking and non‑blocking execution, illustrates their combinations with real‑world analogies, and provides practical guidance on applying servlet async, Spring MVC async, full‑chain async, HTTP client async and database async techniques to improve Java backend throughput and CPU utilization.
Asynchronous ProgrammingHTTP ClientJava
0 likes · 17 min read


JD TechJun 28, 2018 · Backend Development
This article introduces the concepts of synchronous versus asynchronous calls, explains the challenges of RPC services in large-scale systems, and provides detailed guidance on using polling, callbacks, futures, and CompletableFuture in Java to implement efficient, non‑blocking backend architectures with practical code examples.
Asynchronous ProgrammingBackendCallback
0 likes · 18 min read

This article introduces asynchronous programming concepts, focusing on Promise-style APIs, their differences from synchronous and callback approaches, and practical usage patterns in backend development.
Asynchronous ProgrammingCompletableFutureListenableFuture
0 likes · 17 min read

The article recaps the first Frontend Technology Salon, covering ES6 fundamentals, Webpack packaging, and practical ES6 asynchronous programming examples, offering detailed explanations and code demonstrations for frontend developers and highlights common pitfalls and browser compatibility issues.
Asynchronous ProgrammingES6JavaScript
0 likes · 5 min read

libco, the high‑performance C/C++ coroutine library powering WeChat’s backend since 2013, enables agile synchronous‑style programming with massive concurrency, offering features like CGI support, shared‑stack mode, hook‑based API interception, and coroutine‑private variables, allowing seamless, non‑intrusive async transformation of hundreds of services.
Asynchronous ProgrammingC++coroutine
0 likes · 10 min read

Node.js 7 now supports the async/await syntax, allowing developers to write asynchronous code without callbacks, promises, or generators, and this guide explains how to install Node.js 7, run a simple example, and use the required --harmony-async-await flag while noting its experimental status.
Async/AwaitAsynchronous ProgrammingNode.js
0 likes · 3 min read


21CTOJun 10, 2016 · Frontend Development
This article shares practical techniques—on‑demand fetching, lazy loading, caching, asynchronous operations, merge handling, visual tricks, unit testing, and logging—that transformed a sluggish desktop monitoring client into a fast, stable, and responsive application, reducing startup from minutes to seconds.
Asynchronous ProgrammingC#Caching
0 likes · 18 min read


21CTOMar 19, 2016 · Backend Development
This article explains how Twitter’s open‑source Finagle framework, built on Netty and written in Scala/Java, provides a fault‑tolerant, protocol‑agnostic RPC layer with load balancing, metrics, tracing, and filters, enabling massive tweet traffic without latency or downtime.
Asynchronous ProgrammingFinagleNetty
0 likes · 11 min read
