如果您担心Akka调度程序的准确性，那么一旦我发现自己处于相同的情况，我会告诉您我的解决方案。对于这种场景，也许有更好的实践，但这个方案对我来说效果很好。如有任何改进和建议，我将不胜感激。不是很长时间间隔的调度工作，我创建了一个调度器，它向自己发送滴答，以便知道什么时候应该执行工作。假设您想安排一些从date A到date B的工作，并执行每个T时间单位(这可能是毫秒到几年)。然后，我的演员所做的就是调度(使用正常的Akka调度程序)，在当前时间和它应该执行第一项工作的时间间隔的一半的时间上进行一次滴答。这基本上是二进制搜索。这样，演员就不会一直滴答作响，在正确的时间执行工作也会非常准确。有关更多信息，请参见下面的Java代码：

public class WorkScheduler extends UntypedActor {

    public static Props props(final Date from, final Date to, final long every, final TimeUnit unit) {
        return Props.create(new Creator<WorkScheduler>() {
            private static final long serialVersionUID = 1L;

            @Override
            public WorkScheduler create() throws Exception {
                return new WorkScheduler(from, to, every, unit);
            }
        });
    }

    // Thresholds to avoid ticking at very long (or very short) intervals 
    private static final long MIN_TICK_DELTA = 1000 // 1 sec.
    private static final long MAX_TICK_DELTA = 21600000 // 6 hours

    private class Tick extends Message {
    }

    private long from;
    private long to;
    private long dt;
    private long checkpoint;

    public WorkScheduler(Date from, Date to, long every, TimeUnit unit) {
        this.from = from.getTime();
        this.to = to.getTime();
        this.dt = unit.toMillis(every);
    }

    @Override
    public void preStart() throws Exception {
        scheduleNextTick(); // The first tick
    }

    private void scheduleNextTick() {
        long t = new Date().getTime();

        // Compute next checkpoint
        if (t < from) {
            checkpoint = from;
        } else {
            long k = (t - from) / dt;
            if ((t - from) % dt != 0) ++k;
            checkpoint = from + k * dt;
        }

        if (checkpoint > to) { // All works executed. Shutdown.
            getContext().stop(self());
        } else { // Schedule next tick
            long delta = Math.max(MIN_TICK_DELTA, Math.min((checkpoint - t) / 2, MAX_TICK_DELTA));
            getContext().system().scheduler().scheduleOnce(
                    FiniteDuration.apply(delta, TimeUnit.MILLISECONDS),
                    self(),
                    new Tick(),
                    getContext().dispatcher(),
                    null);
        }
    }

    @Override
    public void onReceive(Object msg) throws Exception {
        if (msg instanceof Tick) {
            long t = new Date().getTime();
            if (t >= checkpoint) {
                if (t >= checkpoint + dt) // Tick came too late, due to some external delay (like system restart)
                   ;

                // execute work here, preferably spawning a new actor 
                // responsible for doing the work in asynchronous fashion
            }
            scheduleNextTick();
        } else
            unhandled(msg);
    }

}