Question

我需要建立一个系统，每天至少需要创造/安排十万个工作岗位。我查看了多个任务队列，但没有太多支持调度说像石英以分布式方式，一个好的解决方案似乎是芹菜（我是一个java人，我不能使用python），

Akka（这看起来像一个很好的解决方案，可扩展，持久等，但调度似乎有一个限制，就像我需要根据用户请求在一天中的不同时间安排1,00,000个工作）.new to akka please correct我，如果我错了。

我不需要和分配锁用于调度，而是我需要以异步方式进行并发。请提出替代方案。打开scala / java / javascript作为语言。

Quartz不具备可扩展性（存在一些严重的限制），我每天必须发送大约3亿条消息，这些消息将通过1,00,000个作业发送

Answer 1

如果您担心Akka调度程序的准确性，一旦我发现自己处于相同的情况，我会告诉您我的解决方案。也许这种情况有更好的做法，但这个对我很好。我将不胜感激任何改进和建议。我创建了一个调度actor，它不会在很长的时间间隔内调度工作，它会向自己发送tick，以便知道应该何时执行工作。假设您要安排从日期 A 到日期 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);
    }

}

希望它有所帮助））

框架适用于大规模的分布式调度任务队列

1 个答案: