Mastering PowerJob: A Deep Dive into the Next‑Gen Java Distributed Scheduler

Introduction

PowerJob is an enterprise‑grade distributed task scheduling platform built with Java. Similar to XXL‑Job, it provides a web UI for configuring and monitoring scheduled tasks, offering a simple and fast onboarding experience.

Key Features

Easy to Use : A front‑end web interface lets developers visually manage tasks (create, read, update, delete), monitor execution status, and view logs.

Rich Timing Strategies : Supports CRON expressions, fixed frequency, fixed delay, and API‑driven scheduling.

Multiple Execution Modes : Offers single‑node, broadcast, Map, and MapReduce modes, enabling cluster‑distributed computation with minimal code.

Workflow Support : Allows visual DAG configuration, data passing between upstream and downstream tasks, and various node types (decision nodes, nested workflow nodes).

Broad Executor Support : Works with Spring Bean, built‑in or external Java classes, and can integrate Shell, Python, HTTP, SQL processors via official dependencies.

Operations Friendly : Real‑time log display in the web console reduces debugging effort and boosts development efficiency.

Lightweight Dependencies : Requires only a relational database such as MySQL, PostgreSQL, Oracle, or MS SQL Server.

High Availability & Performance : Designed with lock‑free scheduling; deploying multiple servers provides horizontal scalability and high availability.

Failover & Recovery : Configurable retry policies ensure tasks complete as long as executor nodes are available.

Compared with other schedulers, PowerJob’s lock‑free design delivers stronger performance and scalability.

Supported Scheduling Types

API : Triggered via client API; the server does not schedule automatically, suitable for one‑off or tightly coupled business scenarios.

CRON : Standard cron expression scheduling.

Fixed Frequency : Executes every N milliseconds.

Fixed Delay : Executes after a delay of N milliseconds.

Workflow : Executes as part of a defined workflow when the workflow node reaches the task.

Installation

PowerJob can be installed either by running the JAR directly or via Docker. Detailed Docker instructions are available in the official documentation.

To run from source:

Clone the repository from GitHub and build the project.

Open the powerjob-server module in your IDE; powerjob-worker-samples contains Spring Boot usage examples.

Create a database (e.g., MySQL) and run the following SQL:

CREATE DATABASE IF NOT EXISTS `powerjob-daily` DEFAULT CHARSET utf8mb4;

Update application-daily.properties with your database connection details. The daily, pre, and product profiles correspond to development, pre‑production, and production environments.

Start the server class PowerJobServerApplication. After a successful launch, access http://localhost:7700 and you should see the login page.

Creating a Scheduled Task (Client Side)

Add the Maven dependency:

<dependency>
    <groupId>tech.powerjob</groupId>
    <artifactId>powerjob-worker-spring-boot-starter</artifactId>
    <version>4.3.2</version>
</dependency>

Configure the client in application.yml (example shown below):

powerjob:
  worker:
    enabled: true
    enable-test-mode: false
    # Data transfer port, default 27777
    port: 27777
    # Application name, must match the server‑side account
    app-name: powerjob-agent-test
    # Server address, multiple separated by commas
    server-address: 127.0.0.1:7700
    # Protocol (http or akka), http is recommended
    protocol: http
    max-result-length: 4096
    max-lightweight-task-num: 1024
    max-heavy-task-num: 64

Add @EnableScheduling to the Spring Boot main class.

Implement a processor by extending BasicProcessor and annotate it as a Spring bean:

@Component
public class SimpleJobServer implements BasicProcessor {
    @Override
    public ProcessResult process(TaskContext taskContext) throws Exception {
        String jobParams = taskContext.getJobParams();
        System.out.println("Parameters: " + jobParams);
        System.out.println("Executing scheduled task");
        return new ProcessResult(true, "Task executed successfully");
    }
}

Run the client; the server UI will display the new machine instance.

In the server console, create a new task, specify the processor class (e.g., com.example.powerjobdemo.job.SimpleJobServer), and configure timing, execution mode, and other parameters.

Task Configuration Details

Timing Information : Choose the scheduling type (API, CRON, Fixed Frequency, Fixed Delay, Workflow, Daily Fixed Interval, etc.).

Lifecycle : Define the active period for the task, allowing execution only within a specified time window.

Execution Configuration :

Execution types include single‑node, broadcast, Map, and MapReduce.

Single‑node runs on any available executor.

Broadcast runs on all executors (e.g., log cleanup across machines).

Map splits input data into chunks for parallel processing; MapReduce adds a reduce phase for complex aggregation.

Runtime Configuration :

Node selection strategies: HEALTH_FIRST (first healthy node) or RANDOM.

Maximum instance count controls how many executor nodes run the task.

Thread concurrency and execution time limits can be set.

For more details, refer to the official documentation: https://www.yuque.com/powerjob/guidence/ysug77