rabbitmq - 大规模分布式调度任务队列的框架

Question

我需要构建一个系统，每天至少需要创建/安排十万个工作岗位。我研究了多个任务队列，但对调度的支持不多，比如分布式的 quartz ，一个好的解决方案似乎是 celery (我是一个java人，我不能使用python)，

Akka(这看起来是一个很好的解决方案，可扩展、持久等，但调度似乎有一个限制，比如我需要根据用户请求在一天的不同时间安排 1,00,000 个作业)。新来 akka 请更正如果我错了，我会说。

我不需要分布式锁来进行调度，而是需要异步方式的并发。请提出替代方案。开放 scala/java/javascript 作为一种语言。

Quartz 不可扩展(有一些严重的限制)，我每天必须发送大约 3 亿条消息，这些消息将通过 1,00,000 个作业传递

Answer 1

如果你担心Akka调度器的准确性，一旦我发现自己遇到同样的情况，我会告诉你我的解决方案。也许对于这种情况有更好的做法，但这对我来说效果很好。我将不胜感激任何改进和建议。我没有将工作安排在很长的时间间隔内，而是创建了一个调度参与者，它向自身发送滴答信号，以便知道何时应该执行工作。假设您要安排从日期A到日期B的一些工作，并每隔T时间单位执行一次(这可能是从毫秒到年) )。然后我的 Actor 所做的就是在当前时间和应该执行第一项工作的时间之间的时间间隔的一半处精确地调度(使用普通的 Akka 调度程序)一个刻度。这基本上就是二分搜索。这样， Actor 就不会一直滴答作响，并且会非常准确地在正确的时间执行工作。有关详细信息，请参阅下面的 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);
    }

}

希望有帮助))