Wie plant Cron intern Jobs?

Der von diesem Cron verwendete Algorithmus lautet wie folgt:

1. Suchen Sie beim Start nach einer Datei namens .crontab in den Home-Verzeichnissen aller Kontoinhaber.
2. Bestimmen Sie für jede gefundene crontab-Datei das nächste Mal in der Zukunft, dass jeder Befehl ausgeführt werden soll.
3. Platzieren Sie diese Befehle auf der Franta-Maly-Ereignisliste mit ihrer entsprechenden Zeit und ihrer "Fünffelder"-Zeitangabe.
4. Hauptschleife eingeben:
   1. Untersuchen Sie den Aufgabeneintrag am Anfang der Warteschlange und berechnen Sie, wie weit in der Zukunft er ausgeführt werden soll.
   2. Schlafen Sie für diesen Zeitraum.
   3. Führen Sie nach dem Aufwachen und nach Überprüfung der korrekten Zeit die Aufgabe am Anfang der Warteschlange (im Hintergrund) mit den Rechten des Benutzers aus, der sie erstellt hat.
   4. Bestimmen Sie das nächste Mal in der Zukunft, um diesen Befehl auszuführen, und platzieren Sie ihn zu diesem Zeitpunkt wieder auf der Ereignisliste

Ich habe einen Blogbeitrag geschrieben, der es beschreibt.
Zitieren Sie den entsprechenden Text von dort:

• Wir können einen endlichen Thread-Pool haben, der alle Aufgaben ausführt, indem er sie von einem PriorityBlockingQueue abholt (threadsicherer Heap) priorisiert auf job.nextExecutionTime() .
• Das bedeutet, dass das oberste Element dieses Haufens immer dasjenige sein wird, das am schnellsten ausgelöst wird.
• Wir folgen dem Standard-Threadpool-Producer-Consumer-Muster.
• Wir werden einen Thread haben, der in einer Endlosschleife läuft und neue Jobs an den Thread-Pool sendet, nachdem er sie aus der Warteschlange verbraucht hat. Nennen wir ihn QueueConsumerThread :

void goToSleep(job, jobQueue){
    jobQueue.push(job);
    sleep(job.nextExecutionTime() - getCurrentTime());
}

void executeJob(job, jobQueue){
    threadpool.submit(job); // async call
    if (job.isRecurring()) {
        job = job.copy().setNextExecutionTime(getCurrentTime() + job.getRecurringInterval());
        jobQueue.add(job);
    }
}

@Override
void run(){
    while(true)
    {
        job = jobQueue.pop()
        if(job.nextExecutionTime() > getCurrentTime()){
            // Nothing to do
            goToSleep(job, jobQueue)
        }
        else{
            executeJob(job, jobQueue)
        }
    }
}

• Es wird einen weiteren Thread geben, der die crontab-Datei auf neu hinzugefügte Jobs überwacht und sie in die Warteschlange schiebt.
• Nennen wir es QueueProducerThread :

@Override
void run()
{
    while(true)
    {
        newJob = getNewJobFromCrontabFile() // blocking call
        jobQueue.push(newJob)
    }
}

• Dabei gibt es jedoch ein Problem:
  • Stellen Sie sich vor, dass Thread1 schläft und nach einer Stunde aufwacht.
  • Inzwischen trifft ein neuer Task ein, der jede Minute laufen soll.
  • Diese neue Aufgabe kann erst eine Stunde später ausgeführt werden.
• Um dieses Problem zu lösen, können wir ProducerThread anweisen, ConsumerThread zwangsweise aus dem Ruhezustand zu wecken, wenn die neue Aufgabe früher als die vordere Aufgabe in der Warteschlange ausgeführt werden muss:

@Override
void run()
{
    while(true)
    {
        newJob = getNewJobFromCrontabFile() // blocking call
        jobQueue.push(newJob)
        if(newJob == jobQueue.peek())
        {
            // The new job is the one that will be scheduled next.
            // So wakeup consumer thread so that it does not oversleep.
            consumerThread.interrupt()
        }
    }
}

Beachten Sie, dass cron auf diese Weise möglicherweise nicht intern implementiert ist. Dies ist jedoch die optimalste Lösung, die ich mir vorstellen kann. Es erfordert keine Abfrage und alle Threads schlafen, bis sie irgendetwas tun müssen.