An Alternative to Akka Quartz: Time & TimeZone(IST and others) based jobs using Akka Scheduler

In this blog, we will be scheduling jobs based on time using Akka scheduler. The jobs will be scheduled based on IST(Indian Standard Time). It is basically an alternative to Quartz Scheduler to some extent which is also used to schedule the time-based job. We can schedule jobs at any point of time i.e schedule jobs based on IST or any other TimeZone like UTC

Let’s say, If you want your job to be scheduled at 9:00:00 AM IST every day, What would you do?. Scheduling such a job using the normal Akka scheduler is not easy. So what I have done is, I have
written an extra function so that our normal Akka scheduler acts as a Quartz Scheduler but only ‘Time Based ’ not Calendar based. With the example I am going to share you will be able to schedule time-based jobs for almost any TimeZone, you just need to mention the timezone. In this example, I am focusing on IST(Indian Standard Time) but you can tweak it.

Send an E-mail every day at 09:00:00 AM every day.

Akka quartz is one way, but If you can play around with normal Akka scheduler why mess around with Akka quartz.

Alright Let’s head over to the code and see How can we accomplish it.

Here is the Schedule Actor Class


class ScheduleActor extends Actor {

  import ScheduleActor._

  var count = 1
//I am using var over here because it's a simple example to increment count. However you should prefer immutability wherever possible.
  def receive: PartialFunction[Any, Unit] = {
    case IncrementNumber => count+=1


 * Created by deepak on 22/1/17.
object ScheduleActor {

  case object IncrementNumber


Here is the implementation for the job.

import java.text.SimpleDateFormat
import java.util.{Date, TimeZone}

import scala.concurrent.duration._

import ScheduleActor.IncrementNumber
import{ActorSystem, Props}

 * Created by deepak on 22/1/17.
object ScheduleJob extends App {

  val system = ActorSystem("SchedulerSystem")
  val schedulerActor = system.actorOf(Props(classOf[ScheduleActor]),
  implicit val ec = system.dispatcher
    .schedule(calculateInitialDelay().milliseconds, 60.seconds)(
      schedulerActor ! IncrementNumber)
//the first argument in the schedule function is the initial delay 
//the second argument in the schedule function is the interval
  def calculateInitialDelay(): Long = {
    val now = new Date()
    val sdf = new SimpleDateFormat("HH:mm:ss")
    val time1 = sdf.format(now)
    val time2 = "00:00:00" //this is where we provide the time(IST)
 for example I want the job scheduled at 9PM IST I would replace 00:00:00
 with 21:00:00 
    val format = new SimpleDateFormat("HH:mm:ss")
    val date1 = format.parse(time1)
    val date2 = format.parse(time2)
    val timeDifference = date2.getTime() - date1.getTime()
    val calculatedTime = if (timeDifference < 0) 
(Constant.DAYHOURS + timeDifference) else timeDifference
    // val modifiedDate = projectDbService.getModifiedDate("sumit")
//Calculate initial delay method basically triggers the job at the IST 
time provided above.

That’s all, you are all set to schedule time-based jobs without using Quartz Scheduler.

Full code is available on github
If you find any challenge, Do let me know in the comments.
If you enjoyed this post, I’d be very grateful if you’d help it spread.Keep smiling, Keep coding! Cheers!


About deepak028

There is nothing much to describe me.However, I am a very ordinary person who believes in sharing knowledge.
This entry was posted in Scala. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s