Tagged articles
Quartz
100 articles · Page 1 of 1
The article compares Spring @Scheduled, Quartz, and db-scheduler for clustered scheduling, showing how db-scheduler uses a single database table to provide cluster-safe mutex, persistence, and one-time delayed tasks without the overhead of Quartz's eleven tables or external middleware.
JavaQuartzSpring Boot
0 likes · 13 min read

This guide details building a production-grade Spring Boot Quartz scheduler covering JDBC persistence, cluster coordination via database locks, misfire policies, dynamic job management, execution logging via JobListener, idempotency patterns, monitoring metrics, and troubleshooting common pitfalls like transaction boundaries and clock drift.
ClusterIdempotencyPerformance Tuning
0 likes · 20 min read


ITPUBJun 21, 2026 · Backend Development
The article provides a detailed analysis of three popular Java scheduling solutions—@Scheduled, Quartz, and XXL‑Job—highlighting their core features, differences, common pitfalls, and practical advice for selecting the right tool based on project requirements and deployment scenarios.
@ScheduledDistributed SystemsJava
0 likes · 13 min read

The article explains the concept of delayed tasks versus scheduled tasks and evaluates several backend solutions—including database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET, Redis key‑space notifications, and RabbitMQ delayed queues—detailing their implementations, code samples, advantages, and drawbacks for automatically cancelling orders that remain unpaid for a set period.
Delayed TaskJavaQuartz
0 likes · 17 min read

The article provides a detailed comparison of three Java scheduling solutions—Spring's @Scheduled, Quartz, and XXL‑Job—covering their underlying mechanisms, key features, typical scenarios, common pitfalls, and practical recommendations to help developers select the most suitable option for their projects.
@ScheduledBackendQuartz
0 likes · 18 min read

This guide explains how to build a configurable Java scheduling microservice using the Quartz framework, covering task entity CRUD integration, a utility class for creating, updating, pausing, and deleting jobs, and concrete code examples that demonstrate building JobDetails, CronTriggers, and invoking the scheduler.
JavaQuartzcron
0 likes · 4 min read

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.
Asynchronous ProcessingExcel ExportQuartz
0 likes · 10 min read

This article outlines the key building blocks of a microservice architecture—including Nginx as the traffic entry, Spring Cloud Gateway, service registration, Redis caching, MySQL persistence, Elasticsearch, message queues, ELK logging, distributed scheduling, and object storage—providing practical guidance on design choices and high‑availability setups.
ElasticsearchMinIONginx
0 likes · 9 min read

This comprehensive guide explains the fundamentals and practical implementations of task scheduling in Java, covering Linux crontab, JDK Timer, ScheduledExecutorService, Quartz, Spring Schedule, and popular distributed schedulers like SchedulerX, elastic‑job, XXL‑Job and LTS, with code examples and configuration details.
Distributed SchedulingJavaQuartz
0 likes · 23 min read

This article explains how Spring Task and Quartz achieve timed job execution by using a DelayedWorkQueue backed by a binary min‑heap, detailing the scheduling flow, task ordering, and core heap operations with illustrative code examples.
DelayedWorkQueueJava ConcurrencyQuartz
0 likes · 9 min read

This article demonstrates how to build an automated monthly billing system for part-time payroll using the Chengwu low-code platform, leveraging Quartz scheduled tasks, LogicFlow process engine, Amis frontend forms, MySQL database, and notification modules to handle data aggregation, rule-based salary calculation, bill generation, user notifications, and audit trails.
AMisQuartzlow-code
0 likes · 13 min read

This article explores various techniques for implementing delayed tasks in Java, comparing Quartz database polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets, and RabbitMQ delayed queues, detailing their implementations, advantages, drawbacks, and practical code examples for handling order timeouts.
JavaQuartzRabbitMQ
0 likes · 16 min read

This article explains why orders that remain unpaid for 30 minutes should be automatically cancelled and compares five technical approaches—database polling, JDK Timer, message‑queue delayed queues, distributed schedulers like Quartz, and Redis expiration listeners—detailing their implementation steps, code samples, pros, cons, and suitable scenarios.
Message QueueQuartzSpring
0 likes · 19 min read

Drawing on experience with TimerTask, Quartz, SpringTask, HashWheelTimer, Elastic‑Job, XXL‑JOB, and AirFlow, the author created a teaching‑focused, horizontally scalable task‑scheduling platform supporting over 100 000 jobs, organized into gateway, admin, and worker layers, with a detailed architecture and tech‑stack overview.
NettyQuartzTask Scheduling
0 likes · 6 min read

This article surveys eleven Java‑based delayed‑task solutions—including DelayQueue, Timer, ScheduledThreadPoolExecutor, RocketMQ, RabbitMQ, Redis key‑expiration, Redisson, Netty’s HashedWheelTimer, Hutool SystemTimer, Quartz, and a simple polling loop—providing code demos, implementation principles, and practical pros and cons for each approach.
DelayQueueQuartzRabbitMQ
0 likes · 25 min read

This article explains the fundamentals of distributed task scheduling, describes its key components—Scheduler, Trigger, and Job—and reviews popular frameworks such as Quartz, Elastic-Job, and XXL-Job, providing a concise guide for backend engineers.
BackendDistributed SchedulingElastic-Job
0 likes · 6 min read


LouZaiMar 14, 2024 · Backend Development
This article analyzes multiple engineering solutions for automatically cancelling orders after the payment timeout, covering single‑machine and cluster scheduled‑task designs (Quartz, ElasticJob, XXL‑JOB), delayed‑message techniques (RocketMQ, custom delay service, Redis), and essential concurrency and monitoring best practices.
ElasticJobQuartzRedis
0 likes · 13 min read

This article explains the concept of delayed tasks, distinguishes them from scheduled tasks, and presents six practical Java implementations—including Quartz database polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets, Redis key‑space notifications, and RabbitMQ delayed queues—along with their advantages and drawbacks.
JavaQuartzRabbitMQ
0 likes · 14 min read

This article reviews six practical approaches for scheduling recurring jobs in Java—including custom threads, JDK ScheduledExecutorService, Spring @Scheduled, Quartz, Elastic‑Job, and XXL‑JOB—highlighting their usage, configuration steps, and considerations for clustering and concurrency.
Distributed SchedulingJavaQuartz
0 likes · 6 min read

This article explains the concept of delayed tasks, compares them with scheduled tasks, and evaluates multiple implementation strategies—including database polling, JDK DelayQueue, Netty HashedWheelTimer, Redis ZSET, Redis keyspace notifications, and RabbitMQ delayed queues—highlighting their advantages and drawbacks for order‑processing scenarios.
JavaQuartzRabbitMQ
0 likes · 15 min read

This article compares delayed tasks with scheduled tasks and presents six practical Java solutions—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET, Redis key‑space notifications, and RabbitMQ delayed queues—detailing their implementations, advantages, and drawbacks for handling order‑timeout scenarios.
DelayQueueJavaQuartz
0 likes · 16 min read

The article explains the concept of delayed tasks versus scheduled tasks in payment systems, outlines their key differences, and evaluates five practical implementation approaches—Quartz database polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET/Keyspace notifications, and RabbitMQ delayed queues—detailing their code examples, advantages and drawbacks.
DelayQueueJavaQuartz
0 likes · 16 min read

This article explains why Quartz jobs can overlap when their execution time exceeds the trigger interval, demonstrates how to prevent concurrent execution with the @DisallowConcurrentExecution annotation, discusses distributed lock and idempotency solutions for clusters, and covers thread‑pool limits, exception handling, and a complete Java demo.
ConcurrencyDisallowConcurrentExecutionJava
0 likes · 5 min read

This article compares delayed and scheduled tasks, analyzes several implementation approaches—including database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET and key‑space notifications, and RabbitMQ delayed queues—provides code examples, and discusses the advantages and drawbacks of each method for handling order timeout scenarios in payment systems.
JavaQuartzRedis
0 likes · 17 min read

This article explains how to reduce database pressure by counting likes and views in Redis, designing a hash‑based storage structure, synchronizing cached data to MySQL with Quartz, and marking articles as liked for each user, while also outlining current limitations.
JavaQuartzRedis
0 likes · 7 min read

This article provides a detailed tutorial on the Quartz scheduling framework for Java, covering its core concepts, basic setup with SimpleTrigger and CronTrigger, advanced features like multiple triggers, bean injection, and persistent storage configuration, complete with code examples and resources.
JavaJobQuartz
0 likes · 21 min read

This tutorial walks through Quartz’s core concepts, basic and advanced usage in Spring Boot—including job, trigger, and scheduler setup, multiple triggers, bean injection, and persistent storage—complete with code examples and diagrams for clear understanding.
JavaJobPersistence
0 likes · 25 min read

To reduce database load from high‑frequency like and favorite actions, the article outlines a backend solution that stores per‑article like data in Redis hashes, periodically synchronizes the cached data to MySQL using Quartz scheduled jobs, and shows how to indicate whether a user has liked each article.
JavaQuartzRedis
0 likes · 7 min read

This article examines common business scenarios requiring timed tasks, reviews single‑machine and distributed scheduling frameworks, and provides a detailed comparison of Elastic‑Job, X‑Job, and Quartz, highlighting their strengths, weaknesses, deployment models, and suitability for different scale requirements.
Elastic-JobQuartzTask Scheduling
0 likes · 11 min read

This article compares popular Java task scheduling solutions—including Quartz, Spring Schedule with Redis locks, ElasticJob‑Lite, centralized MQ and XXL‑JOB approaches—explaining their core components, clustering strategies, code examples, and practical selection guidance for building reliable distributed schedulers.
ElasticJobQuartzXXL-JOB
0 likes · 19 min read

This article compares popular Java task scheduling solutions—including Quartz, ElasticJob‑Lite, XXL‑JOB, and custom implementations—explaining their core components, clustering strategies, distributed lock mechanisms, and practical code examples to help engineers choose the right framework for their needs.
ElasticJobQuartzTask Scheduling
0 likes · 20 min read

This article provides a comprehensive overview of DolphinScheduler’s design strategies, distributed architecture, fault‑tolerance mechanisms, configuration files, core APIs, Quartz integration, master‑worker execution flow, RPC communication, load‑balancing algorithms, and logging services, accompanied by detailed code excerpts and diagrams.
Distributed SystemsDolphinSchedulerQuartz
0 likes · 46 min read

This article provides an in‑depth tutorial on using the Quartz scheduler in Java, covering its core concepts, basic and advanced configurations, code examples for interval and Cron‑based jobs, multi‑trigger setups, bean injection techniques, and how to persist jobs with JDBCJobStore.
JavaJobQuartz
0 likes · 19 min read

This article introduces Quartz, the Java‑based open‑source scheduler behind many distributed task‑scheduling frameworks, compares its RAMJobStore and JDBCJobStore options, shows step‑by‑step Spring Boot integration with code samples, and explains the internal architecture and lifecycle of the scheduler.
Distributed SchedulingJDBCJobStoreJava
0 likes · 19 min read

This article introduces Quartz, a Java job‑scheduling library, explains its core components (Job, Trigger, Scheduler), provides step‑by‑step Maven demos, shows how to integrate it with Spring Boot, configure persistence, manage concurrency, and handle advanced features like cron expressions and calendar exclusions.
ConcurrencyCronTriggerQuartz
0 likes · 25 min read

This article provides an in‑depth technical overview of Apache DolphinScheduler, covering its distributed design strategies, fault‑tolerance mechanisms, remote log access, source‑code module breakdown, API interfaces, Quartz integration, master‑worker execution flows, RPC communication, load‑balancing algorithms, logging services, and community contribution guidelines.
Distributed SchedulingDolphinSchedulerFault Tolerance
0 likes · 47 min read

This article provides a comprehensive guide to using Quartz in Java Spring Boot, covering core concepts, basic and advanced usage—including job creation, triggers, Cron expressions, bean injection, multiple triggers, and persistence with JDBC—complete with code samples and configuration steps.
JavaJobQuartz
0 likes · 22 min read

This article examines common business scenarios that require timed execution, explains why scheduled tasks are essential, compares single‑node Java scheduling options with distributed frameworks like Quartz, Elastic‑Job, Saturn and XXL‑Job, and provides a detailed feature‑by‑feature analysis to help developers select the most suitable scheduler.
Elastic-JobJavaQuartz
0 likes · 13 min read

This article provides a detailed overview of the Quartz scheduling framework for Java, covering its core concepts, basic and advanced usage with Spring Boot, code examples for interval and Cron‑based jobs, multi‑trigger configurations, bean injection techniques, and database persistence setup.
JavaJobQuartz
0 likes · 21 min read

This article provides a detailed tutorial on Quartz, a powerful Java scheduling framework, covering its core concepts, basic usage with SimpleTrigger and CronTrigger, advanced features such as multiple triggers, bean injection, and persistence, and includes complete Spring Boot code examples.
JavaJobPersistence
0 likes · 22 min read

This article provides a comprehensive guide on using the Quartz job‑scheduling library in Java, covering core concepts such as Job, Trigger, and Scheduler, showing Maven setup, sample job and trigger code, Spring Boot configuration, utility classes for creating and managing jobs, handling concurrency, misfire policies, and REST‑based job management.
QuartzSpring Bootcron
0 likes · 20 min read

The article examines common business scenarios that require timed execution, explains why scheduled tasks are needed, lists single‑machine and distributed Java scheduling frameworks, and provides a detailed feature‑by‑feature comparison between two popular distributed schedulers, X‑Job and Elastic‑Job.
Elastic-JobQuartzScheduling
0 likes · 13 min read

This article examines the need for scheduled tasks in various business scenarios, reviews single‑machine and distributed Java scheduling frameworks such as Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, elastic‑job, Saturn, and XXL‑Job, and provides a detailed comparative analysis to guide framework selection.
BackendDistributed SchedulingElastic-Job
0 likes · 12 min read

This article examines common business scenarios that require timed tasks, explains why scheduling is essential, reviews single‑machine and distributed Java scheduling frameworks—including Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, elastic‑job, Saturn, and xxl‑job—then provides a detailed feature comparison, deployment considerations, and practical recommendations.
BackendDistributed SchedulingElastic-Job
0 likes · 13 min read

This article provides a comprehensive guide to integrating the Quartz job‑scheduling library with Spring Boot, covering core concepts, Maven setup, job and trigger definitions, concurrency control, dynamic task creation via REST, and initialization strategies, all illustrated with complete Java code examples and diagrams.
JavaJobQuartz
0 likes · 22 min read

The article compares five delayed‑task implementations—database polling, JDK DelayQueue, Netty time wheel, Redis sorted sets, and RabbitMQ dead‑letter queues—detailing their concepts, Java code examples, advantages, and drawbacks to help developers choose the most suitable approach for order‑timeout scenarios.
DelayQueueJavaQuartz
0 likes · 16 min read

The article compares delayed and scheduled tasks and presents five backend solutions—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET, and RabbitMQ delayed queues—detailing their implementations, code examples, outputs, and pros and cons.
BackendDelayQueueJava
0 likes · 19 min read

This article provides a comprehensive guide on using Quartz, a Java‑based job scheduling library, within a Spring Boot application, covering core concepts, Maven dependencies, scheduler configuration, job and trigger creation, concurrency handling, database integration, and practical code examples for managing scheduled tasks.
JavaJobSchedulerQuartz
0 likes · 21 min read

This article explains how to integrate the Quartz job‑scheduling library into a Spring Boot application, covering core concepts, Maven dependencies, sample job and configuration code, trigger types, concurrency control, and runtime management of scheduled tasks.
ConcurrencyJavaQuartz
0 likes · 21 min read

This article explains the core concepts, architectures and trade‑offs of several Java task‑scheduling solutions—including Quartz, Redis/Zookeeper distributed locks, ElasticJob‑Lite, XXL‑JOB and a self‑built scheduler—while providing code examples and practical guidance for building reliable, scalable job execution systems.
ElasticJobJavaQuartz
0 likes · 17 min read

This tutorial explains how to build a highly available, horizontally scalable distributed scheduled‑task system using Quartz in a Spring Boot application, covering application scenarios, Maven dependencies, database initialization, configuration properties, job and scheduler code, and verification of failover behavior.
Distributed SchedulingJavaQuartz
0 likes · 14 min read

This article compares several approaches to implementing delayed tasks in Java, including Quartz polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues, analyzing their principles, code examples, advantages, and drawbacks for order timeout handling.
BackendDelayQueueHashedWheelTimer
0 likes · 16 min read

This article explains the fundamentals of scheduled tasks in Java, compares Timer, ScheduledExecutorService, Quartz and Spring @Schedule, discusses why distributed scheduling is needed in clustered environments, reviews popular frameworks, and provides a step‑by‑step guide to integrating the XXL‑JOB framework into the Austin project for dynamic task management.
Distributed SystemsJavaQuartz
0 likes · 13 min read

This article explains how to handle a PC‑triggered device upgrade record by using Quartz for timed execution and Spring Batch for bulk processing, detailing Maven dependencies, YAML configuration, service and batch classes, custom reader/writer logic, a processor that calls an upgrade‑dispatch API, and the overall challenges encountered.
JavaQuartzSpring Batch
0 likes · 13 min read

This article explains how to use Spring Batch together with Quartz to periodically process device upgrade records, covering Maven dependencies, configuration files, service implementation, batch job and step definitions, a custom processor for HTTP dispatch, entity mapping, and job retry scheduling for failed updates.
JavaQuartzSpring Batch
0 likes · 10 min read

This article explains the concept of delayed tasks, compares them with scheduled tasks, and presents five implementation approaches—database polling, JDK DelayQueue, time‑wheel algorithm, Redis sorted sets, and message‑queue based delay queues—detailing their code, advantages, and drawbacks.
DelayQueueJavaMessage Queue
0 likes · 17 min read

This article explains how to implement fixed‑time scheduled tasks on a single machine using Timer and ScheduledThreadPoolExecutor, how to build a custom Redis‑based distributed scheduler with distributed locks, and compares several third‑party frameworks such as Quartz, TBSchedule, Elastic‑Job and Sature for distributed task execution.
JavaQuartzRedis
0 likes · 8 min read

This article analyzes common business scenarios requiring timed tasks, reviews single‑machine and distributed scheduling solutions such as Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, Elastic‑Job, Saturn, and XXL‑Job, and provides a detailed feature‑by‑feature comparison to help choose the most suitable framework.
BackendDistributed SchedulingElastic-Job
0 likes · 12 min read

This article analyzes a Quartz 2.3.0 job‑scheduling issue where millions of daily triggers caused occasional duplicate executions, explains the underlying lock mechanisms and state transitions, and provides a simple configuration change to prevent the problem in distributed environments.
DebuggingJavaQuartz
0 likes · 13 min read

This article examines why Quartz's job scheduler can produce duplicate executions under high load, explains the internal trigger states, lock mechanisms, and code paths involved, and provides a configuration fix to ensure exclusive trigger acquisition and prevent repeated job runs.
JavaQuartzjob scheduling
0 likes · 13 min read

This article demonstrates how to design and implement a high‑frequency like/unlike feature using Spring Cloud, Redis for caching, MySQL for persistence, and Quartz for scheduled data synchronization, covering cache design, data structures, service interfaces, database schema, and deployment scripts.
CacheLikeFeatureQuartz
0 likes · 17 min read

The article explains the concept of delayed tasks, distinguishes them from scheduled tasks, and evaluates five practical implementation approaches—including database polling, JDK DelayQueue, Netty time‑wheel, Redis sorted‑set and key‑space notifications, and RabbitMQ delayed queues—while providing code samples, performance pros and cons, and deployment considerations.
JavaQuartzRabbitMQ
0 likes · 20 min read

This article examines common business scenarios that require timed tasks, introduces single‑machine and distributed scheduling solutions such as Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, elastic‑job, Saturn, and XXL‑Job, and provides a detailed feature‑by‑feature comparison to help choose the most suitable framework.
Distributed SchedulingElastic-JobQuartz
0 likes · 11 min read

This article examines common business scenarios that require timed operations, explains why scheduled tasks are essential, reviews Java single‑machine and distributed scheduling frameworks such as Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, Elastic‑Job, Saturn and XXL‑Job, and provides a detailed feature comparison to help choose the appropriate solution.
Distributed SchedulingElastic-JobJava
0 likes · 12 min read

This article examines common business scenarios requiring timed tasks, explains why scheduled jobs are essential, compares single‑machine and distributed Java scheduling frameworks, and provides an in‑depth comparison of Elastic‑Job and XXL‑Job across features like clustering, scaling, monitoring, and fault handling.
Distributed SchedulingElastic-JobJava
0 likes · 15 min read

This article examines the concept of delayed tasks versus scheduled tasks, outlines their differences, and presents five practical implementation strategies—including database polling with Quartz, JDK DelayQueue, Netty’s HashedWheelTimer, Redis ZSET and keyspace notifications, and RabbitMQ delayed queues—complete with code samples, performance pros and cons, and scalability considerations.
JavaQuartzRabbitMQ
0 likes · 19 min read

The article explains the concept of delayed tasks versus scheduled tasks and provides five Java‑based solutions—Quartz polling, JDK DelayQueue, Netty HashedWheelTimer, Redis (zset and keyspace notifications), and RabbitMQ delayed queues—detailing their implementations, advantages, and drawbacks.
JavaNettyQuartz
0 likes · 19 min read

This guide explains how to implement periodic tasks in Spring Boot 2.2.11 using the built‑in @EnableScheduling/@Scheduled approach and the Quartz library, covering configuration, cron expressions, core Quartz concepts, and complete code examples for both methods.
JavaQuartzScheduling
0 likes · 8 min read

The article explains the concept of delayed tasks versus scheduled tasks and presents five practical Java implementations—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues—detailing their code, advantages, and drawbacks.
DelayQueueJavaQuartz
0 likes · 18 min read

This article examines common business scenarios requiring timed tasks, compares single‑machine and distributed scheduling frameworks such as Timer, Spring, Quartz, TBSchedule, Elastic‑Job, Saturn and XXL‑Job, and provides guidance on selecting the most suitable solution.
Distributed SchedulingElastic-JobQuartz
0 likes · 15 min read

This article compares delayed tasks with scheduled tasks and presents five practical Java implementations—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues—detailing their code, advantages, and drawbacks.
DelayQueueJavaQuartz
0 likes · 18 min read

This article compares delayed and scheduled tasks, explains their differences, and presents five practical Java implementations—including Quartz polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET, and Redis keyspace notifications—along with their advantages, drawbacks, and sample code.
DelayQueueJavaQuartz
0 likes · 18 min read

This article compares delayed and scheduled tasks, explores five implementation strategies—including database polling, JDK DelayQueue, time‑wheel algorithm, Redis sorted sets, and RabbitMQ—provides code samples, analyzes pros and cons, and offers practical guidance for building reliable delayed‑task systems.
JavaQuartzRedis
0 likes · 23 min read

This article compares several Java-based delayed‑task solutions—including database polling with Quartz, JDK DelayQueue, Netty’s HashedWheelTimer, Redis sorted‑set or key‑space notifications, and RabbitMQ delayed queues—detailing their implementations, advantages, drawbacks, and practical code examples for reliable order‑timeout handling.
JavaQuartzRabbitMQ
0 likes · 19 min read

This article examines common business scenarios requiring timed tasks, explains the differences between timer‑based and message‑driven approaches, and provides a detailed comparison of single‑machine and distributed scheduling frameworks—including Elastic‑Job, Xxl‑Job, and Quartz—highlighting their features, deployment models, and suitable use cases.
Elastic-JobQuartzTask Scheduling
0 likes · 11 min read

The article compares five practical methods—single‑server deployment, IP‑based restriction, database‑driven task selection, Redis expiration with distributed lock, and Quartz clustering—to ensure that a scheduled job runs only once across multiple servers, outlining each approach's advantages, drawbacks, and implementation details.
QuartzRedismysql
0 likes · 5 min read

This article provides a step‑by‑step tutorial on five different ways to implement Java job scheduling—including raw threads, TimerTask, thread pools, Quartz framework, and Spring @Scheduled—followed by detailed instructions for setting up the xxl‑job admin console, configuring a Spring Boot project, and deploying sample job handlers.
JavaQuartzSpring Boot
0 likes · 13 min read

This article compares several Java-based approaches for implementing delayed tasks, including database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets and keyspace notifications, and RabbitMQ dead‑letter queues, analyzing their advantages, disadvantages, and code implementations.
JavaNettyQuartz
0 likes · 18 min read

This tutorial walks through building a scalable like feature using Spring Cloud, Redis caching, MySQL persistence, and Quartz scheduling, covering Redis installation, Spring Boot integration, data modeling, service implementation, and periodic synchronization of high‑frequency like operations to the database.
QuartzRedisSpring Boot
0 likes · 17 min read

Explore ten practical Java scheduling options—from Linux crontab and JDK Thread/Timer to Spring Task, Quartz, and distributed frameworks like XXL‑Job, Elastic‑Job, Saturn and TBSchedule—detailing setup, code examples, advantages, drawbacks, and best‑fit scenarios for reliable task automation.
QuartzSchedulingSpring
0 likes · 22 min read

The author shares a personal journey of discovering why and how to read source code, covering motivations, effective learning methods such as official docs, books, blogs, design‑pattern awareness, and IDE breakpoint debugging, illustrated with a detailed Spring Boot‑Quartz integration example.
Design PatternsJavaQuartz
0 likes · 12 min read

This article demonstrates how to implement a dynamic, non‑blocking Quartz scheduler in a Spring Boot application, allowing tasks to be added, paused, resumed, deleted, or triggered instantly without restarting the service, and provides complete code examples and configuration steps.
Dynamic ConfigurationQuartzSpring Boot
0 likes · 11 min read

This article demonstrates how to implement a dynamic, non‑blocking Quartz scheduling solution in a Spring Boot application, covering Maven dependencies, database schema, initialization steps, custom job factory, listener, and common Scheduler API operations such as pause, resume, delete, and trigger.
Dynamic ConfigurationJavaQuartz
0 likes · 11 min read

The article shares the author's personal experience of reading source code—starting with Java collections, moving to Spring and MyBatis, diving deep into Spring Boot and Quartz integration, and offering practical tips such as using official guides, books, blogs, design‑pattern knowledge, and IDE breakpoint debugging to master backend frameworks.
DebuggingJavaQuartz
0 likes · 14 min read

This guide compares four Java scheduling options—Timer, ScheduledExecutorService, Spring Task, and Quartz—showing how to implement each in Spring Boot, configure cron expressions, enable async execution, and choose the right tool for your needs.
Cron ExpressionsQuartzScheduledExecutorService
0 likes · 12 min read

This article explains how to design a high‑frequency like/unlike feature by caching operations in Redis, persisting data to a relational database at regular intervals, and orchestrating the process with Spring Boot, Spring Cloud, and Quartz scheduled jobs, complete with code examples and schema design.
JavaQuartzSpring Boot
0 likes · 15 min read

The article recounts the author's evolution from avoiding source code to actively reading JDK, Spring, MyBatis, Shiro and Quartz implementations, explains why reading code matters for interviews and personal growth, and shares practical methods—including official docs, books, blogs, and IDE breakpoint debugging with concrete Spring Boot‑Quartz examples.
DebuggingJavaQuartz
0 likes · 13 min read


转转QAJun 11, 2020 · Backend Development
This article explains how to integrate the Quartz scheduler into a Spring Boot application to create, update, delete, pause, and resume dynamic scheduled jobs without restarting the service, covering Quartz fundamentals, storage options, configuration steps, job implementation, and deployment considerations.
QuartzSpring Bootdynamic scheduling
0 likes · 6 min read

The article explains how DBLE 2.19.11.0 replaces the server‑level global table check with a table‑level, Quartz‑driven mechanism that allows precise scheduling, customizable check methods, and easier result handling, and provides configuration examples for the built‑in CHECKSUM and COUNT checks.
DBLEQuartzconsistency checking
0 likes · 5 min read

This article examines the business drivers behind distributed task scheduling, outlines key requirements and pain points, and provides a comprehensive comparison of Java Timer, ScheduledExecutorService, Spring Task, Quartz, XXL‑JOB, Elastic‑Job, and other open‑source frameworks, helping you choose the most suitable solution for your system.
Distributed SchedulingElastic-JobJava
0 likes · 14 min read

This article demonstrates how to design and implement a high‑frequency like/unlike functionality in a Spring Cloud application by using Redis as a cache, persisting data to MySQL at two‑hour intervals, and automating the sync with Quartz scheduled jobs.
Quartzlike systemspring-boot
0 likes · 14 min read

This article walks through designing and implementing a high‑traffic like/unlike feature for a social platform using Spring Cloud, Redis caching, MySQL persistence, and a Quartz‑based scheduled job to sync data every two hours.
QuartzSpring Bootbackend development
0 likes · 17 min read

This article details a complete backend solution for a high‑frequency like/unlike feature using Spring Cloud, Redis as a cache, MySQL for persistence, and Quartz to periodically transfer cached data to the database, covering installation, configuration, data modeling, service design, and scheduled tasks.
BackendLikeFeatureQuartz
0 likes · 15 min read


21CTONov 18, 2019 · Backend Development
This article explains how to design and implement a high‑frequency like/unlike feature for large social platforms using Spring Cloud, Redis caching, MySQL persistence, and Quartz scheduled jobs, covering Redis setup, data modeling, service interfaces, database schema, and periodic data synchronization.
QuartzRedisSpringBoot
0 likes · 19 min read

After discovering misconfigurations in a Spring Boot project’s QuartzJobBean implementation, this article examines the root causes, compares legacy and modern Spring solutions—including custom JobFactory, AutowireCapableBeanFactory, and the spring-boot-starter-quartz starter—and provides detailed code examples to correctly integrate Quartz with Spring’s IoC container.
JavaQuartzautowiring
0 likes · 13 min read

This article provides a comprehensive overview of the Quartz Java scheduling framework, detailing its architecture, core components such as Scheduler, Job, Trigger and JobDetail, typical use cases, Spring‑based cluster deployment configurations, monitoring techniques, and the underlying database‑lock synchronization mechanism.
ClusterJavaJob
0 likes · 10 min read

This article provides a thorough overview of Java task scheduling, covering the native Timer utility, the thread‑pool‑based ScheduledExecutorService, and the powerful Quartz framework, including their APIs, usage patterns, limitations, and integration with Spring for enterprise applications.
JavaQuartzScheduledExecutorService
0 likes · 8 min read

This article outlines the shortcomings of using crontab for large‑scale job execution, defines the requirements for a custom distributed scheduler, describes its three‑component architecture (trigger, monitor, management), and details key technical solutions such as process isolation, distributed locking, and log aggregation.
Distributed SystemsQuartzRedis
0 likes · 12 min read

This tutorial walks through creating a web‑based task scheduling interface with Quartz, covering configuration, job definition, trigger setup, and UI integration to manage scheduled jobs through a visual page, including database persistence and real‑time status monitoring.
QuartzTask SchedulingWeb UI
0 likes · 1 min read

This article presents the design, implementation, and future enhancements of the Ialert system, a Java‑based real‑time API monitoring solution that uses HttpClient, Quartz, and email alerts to provide 24/7 health checks, performance insights, and rapid fault detection across multiple data centers.
API monitoringHttpClientJava
0 likes · 6 min read
