Distributed Java Background Job Scheduler

Fire-and-forget jobs

Fire-and-forget jobs are executed only once and almost immediately after creation.

BackgroundJob.enqueue(
    () -> System.out.println("Simple!"));

Scheduled & delayed jobs

Scheduled and delayed jobs are also executed only once but will run at the specified time.

BackgroundJob.schedule(
  () -> System.out.println("Reliable!"),
  now().plusHours(5));

Recurring jobs

Recurring jobs fire each time on the specified CRON schedule.

BackgroundJob.scheduleRecurringly(
  () -> service.doWork(), 
  Cron.daily());

Queues
PRO

Specify a queue to bypass all jobs already enqueued so your critical business processes finish on-time.

@Job(queue = HighPrioQueue)
public void doWork() { 
    ...
}

Batches & job chaining
PRO

Create a bunch of background jobs atomically using a batch and then chain a new job which will run when the complete batch finishes.

 BackgroundJob
    .startBatch(this::sendEmailToEachSubscriber)
    .continueWith(() -> reportService.createReport(...))
    .continueWith(() -> notifyService.notify("sales-team", ...));

Star us on GitHub!

Why JobRunr

Thanks for building JobRunr, I like it a lot! Before that I used similar libraries in Ruby and Golang and JobRunr so far is the most pleasant one to use. I especially like the dashboard, it’s awesome!
Alex Denisov - Senior software engineer at ShiftLeft
Just came across JobRunr on Github. Exactly what I have been looking for! Went through the source and completely inline with how software should be written. Simple, nicely architectured! Great job!
Pierre-Alexandre Losson - Software architect and entrepreneur
Thanks for sharing. Very helping in a Kubernetes environment.
A reddit user - Developer
Omg…. This being released like a year ago, would be great (for us). Instead, we are hitting a lot of walls trying to use Quartz to replace an old in-house job scheduler
A reddit user - Developer

Simple

Easy to set up, easy to use. Add the jar from Maven Central and start creating jobs. An easy alternative for Spring Batch and Quartz Scheduler.

Background jobs are regular java methods with regular arguments – no super class or interface implementation required.

Persistent

Background jobs are created in a persistent storage and supports RDBMS like MySql/MariaDB, PostgreSQL, Oracle, DB2 and also NoSQL databases like ElasticSearch, Redis and MongoDB.

You can safely restart your application and use JobRunr without worrying about loosing jobs.

Transparent

Thanks to the built-in web interface, you have an overview of all your background jobs and observe the state of each job in detail.

Out of the box support for popular logging frameworks allows you to catch errors early with zero configuration.

Distributed

Background method calls and their arguments are serialized to JSON and can travel over JVM instances.

You can use JobRunr on different machines to get more processing power with no extra configuration – synchronization is performed automatically.

Reliable

Once a background job was created without any exception, JobRunr takes the responsibility to process it at least once.

You are free to throw unhandled exceptions or terminate your application – background jobs will be re-tried automatically.

Extensible

Job filters allow you to add custom features to the background processing in a way similar to servlet filters.

Job storage access is fully abstracted and you can implement support for your favorite storage. Dashboard supports modifications too.

Efficient

JobRunr takes just enough jobs into memory to process them efficiently and does not keep any locks on other jobs. This allows to distribute the jobs in the best possible manner.

Self maintaining

You don’t need to perform manual storage clean-up – JobRunr keeps it as clean as possible and removes succeeded jobs automatically.

Open source

JobRunr is open source software and is completely free for commercial use. It is licensed under LGPLv3 license.

Fork the project and make contributions on GitHub!

Why JobRunr

Receive updates