This article explains how a large e‑commerce platform implements a high‑performance, asynchronous Excel export mechanism using annotation‑driven declarative programming, AOP interception, Quartz scheduling, RocketMQ messaging, and OSS storage to handle massive data sets without blocking user requests.
This article compares Ray Serve and Celery, explaining their design philosophies, scaling models, GPU‑aware scheduling, operational trade‑offs, and real‑world case studies to help engineers choose the right tool for high‑throughput online inference or large‑scale batch processing.
FastAPI’s async model excels with I/O‑bound tasks but can be crippled by CPU‑heavy or blocking code; this guide explains why, compares built‑in BackgroundTasks and run_in_executor, and shows when to offload work to dedicated queues like Celery or Dramatiq for reliable, scalable processing.
This guide walks through setting up RabbitMQ via Docker, configuring Celery with FastAPI, defining asynchronous tasks, launching workers, testing endpoints, and monitoring execution with Flower, providing a complete, step‑by‑step solution for background processing in Python web applications.
Learn how to set up Redis with Docker, integrate it into a FastAPI app using a custom caching decorator, and apply Redis for caching API responses, rate limiting, task queues, and distributed locks, complete with practical code examples and deployment tips.
This article explains the LazyMan interview problem, demonstrates how to build a JavaScript function supporting chainable sleep, eat, and sleepFirst methods using task queues, and provides step‑by‑step code implementations with explanations and visual results.
This guide introduces the Python RQ library, shows how to install it with Redis, and provides multiple code examples covering queue creation, task execution, priority handling, timeouts, batch processing, scheduling, retries, and status tracking for building robust asynchronous back‑end systems.
This article explains what a thread pool is—a collection of pre‑instantiated idle threads that execute tasks efficiently—and outlines the essential steps to implement one, including thread creation, container management, and task interface design.
This article introduces a Java virtual‑thread based asynchronous task framework, detailing its design constraints, a thread‑safe task queue, daemon thread management, and overloaded execute methods for Runnable and Groovy Closure, along with code examples and performance testing considerations.
This article introduces Python's multiprocessing module and the Celery task queue, explains their core concepts, and provides practical code examples for multi‑process parallel computation, inter‑process communication, asynchronous execution, scheduled jobs, result callbacks, retries, and distributed task orchestration.
This article reviews multiple ways to implement periodic tasks in Python, covering simple loops with sleep, libraries such as Timeloop, threading.Timer, sched, schedule, the APScheduler framework, as well as distributed solutions like Celery and Apache Airflow, and provides code examples for each method.
This article details the background, design choices, and architectural evolution of a distributed scheduling system—from a simple Redlock‑based implementation for real‑time alerts to a robust Bull‑powered task queue supporting complex scenarios, load balancing, persistence, and reliable execution across multiple Node.js servers.
This article provides a detailed tutorial on Celery, covering its architecture, installation, task structures, basic and advanced usage, integration with Django, and code examples for creating workers, scheduling tasks, and retrieving results, enabling developers to implement robust asynchronous processing in Python applications.
This guide explains how to set up Celery, a distributed asynchronous task framework, to use Redis both as the message broker and result backend, covering project structure, configuration code, task definition, execution, state monitoring, and common control operations.
This article provides a detailed overview of Celery, covering its architecture, common use cases, installation steps, project structure, task definition, periodic tasks, worker management, distributed deployment, advanced monitoring, custom task handling, task routing, and monitoring with Flower, all illustrated with practical code examples.
This article explains how Kuaishou's Y‑Tech team designs a server‑side video‑effects platform that tackles high computational load, real‑time constraints, and resource limits by adopting asynchronous workflows, task‑queue scheduling, and cloud‑native serverless frameworks such as Netflix Conductor and Knative.
This article explains JavaScript's single‑threaded nature, the various browser threads, how the event loop coordinates synchronous and asynchronous tasks, the roles of macro‑ and micro‑task queues, and how the execution stack processes them to achieve non‑blocking behavior.
This article explores the historical reasons behind JavaScript's event loop, explains the task and microtask queues, compares browser and Node.js implementations, and provides concrete code examples to illustrate how tasks are scheduled and executed across environments.
This article explains why Celery can become unresponsive on Windows, compares version stability, and shows how to configure a periodic heartbeat to Redis so that task queues stay alive, including full Python examples and Celery configuration files.
This article presents the background, core features, system architecture, internal mechanisms, and practical extensions of ZZSCHEDULE, a distributed task scheduling platform built on the open‑source XXL‑JOB framework, detailing its design goals, HA strategies, task dependency handling, and deployment experiences at Zhuanzhuan.
This article explores the origins and purpose of the JavaScript event loop, explains how browsers and Node.js implement it with external and internal queues, compares their differences, and illustrates the concepts through detailed code examples and visual diagrams.
lmstfy is a stateless, Redis‑backed task‑queue service from Meitu that provides delayed execution, automatic retries, priority handling, expiration, and a RESTful HTTP API, while supporting horizontal scaling via namespace‑based token routing, rich Prometheus metrics, and future disk‑based storage extensions.
This article explains JavaScript’s single‑threaded event loop, detailing how the call stack, macro‑ and micro‑task queues, and asynchronous APIs cooperate to schedule code execution, illustrated with diagrams and a step‑by‑step example.
This article explains why asynchronous processing is needed for large‑scale file export and import, outlines typical use cases, compares its pros and cons, and provides a detailed backend architecture, API design, and implementation guidelines with code snippets and diagrams.
This article deep‑dives into Celery task fundamentals, covering how to instantiate tasks with @app.task, customize task names, use binding for self‑reference, implement retries, access request context, and extend tasks via inheritance, all illustrated with clear Python code examples.
Explore how to configure Celery’s periodic (Beat) tasks, perform synchronous task calls, persist results using Redis, monitor workers with Flower, and debug remotely via telnet, with practical code examples and step‑by‑step instructions for robust backend task management.
Juice is an open‑source Mesos‑based distributed task scheduling framework that abstracts Docker tasks, provides REST APIs, leverages Redis queues, and implements custom resource allocation, offering high resource utilization and fault‑tolerant execution for audio‑video processing workloads.
This article explains the JavaScript event loop in depth, covering execution contexts, call stacks, macro‑ and micro‑tasks, and how APIs like setTimeout, Promise, process.nextTick, and setImmediate interact, using clear diagrams and step‑by‑step examples for both browsers and Node.js.
This article reviews Python threading fundamentals—including mutex locks and condition variables—explains their interaction, compares threading.Lock with threading.RLock, and presents a concise implementation of a thread‑safe task queue with illustrative diagrams and test code.
This article explains how queues—such as message queues, task queues, and data‑bus queues—are applied in backend systems for asynchronous processing, system decoupling, data synchronization, traffic shaping, buffering, and other architectural patterns to improve scalability and reliability.
This article explains how the browser’s UI thread manages a task queue to sequentially process UI‑update operations, illustrated with a button‑click example that creates multiple tasks and demonstrates the thread’s idle‑time processing of queued updates.
Learn how to install Celery, configure it with Redis as a broker, write a simple task to send emails asynchronously, and run workers, all demonstrated with clear code snippets and step‑by‑step instructions for Python developers.
