object Scheduler {
    private lazy val sched = Executors.newSingleThreadedScheduledExecutor();
    def schedule(f: => Unit, long time) {
        sched.schedule(new Runnable {
          def run = {
            actors.Scheduler.execute(f)
          }
        }, time - Platform.currentTime, TimeUnit.MILLISECONDS);
    }
}

val execTime = //...
Scheduler.schedule( { Actor.actor { target ! message }; () }, execTime)

import actors.{Actor,TIMEOUT}

def scheduler(time: Long)(f: => Unit) = {
  def fixedRateLoop {
    Actor.reactWithin(time) {
      case TIMEOUT => f; fixedRateLoop
      case 'stop =>
    }
  }
  Actor.actor(fixedRateLoop)
}

case class Ping(t: Long)

import Actor._
val test = actor { loop {
  receiveWithin(3000) {
    case Ping(t) => println(t/1000)
    case TIMEOUT => println("TIMEOUT")
    case 'stop => exit
  }
} }

import compat.Platform.currentTime
val sched = scheduler(2000) { test ! Ping(currentTime) }

scala> 1249383399
1249383401
1249383403
1249383405
1249383407

sched ! 'stop

scala> TIMEOUT
TIMEOUT
TIMEOUT

test ! 'stop

def run = actors.Scheduler.execute(f)

def run = f

object Scheduler {
    private lazy val sched = Executors.newSingleThreadedScheduledExecutor();
    def schedule(f: => Unit, time: Long) {
        sched.schedule(new Runnable {
          def run = f
        }, time - Platform.currentTime, TimeUnit.MILLISECONDS);
    }
}