Empêcher l'exécution de tâches cron en double

J'ai planifié l'exécution d'un travail cron toutes les minutes, mais parfois, le script prend plus d'une minute et je ne veux pas que les travaux commencent à se superposer les uns aux autres. J'imagine qu'il s'agit d'un problème de concurrence, c'est-à-dire que l'exécution du script doit s'exclure mutuellement.

Pour résoudre le problème, j’ai demandé au script de rechercher l’existence d’un fichier particulier (" lockfile.txt ") et de le quitter s’il existait ou touchnon. Mais ceci est un sémaphore assez moche! Existe-t-il une meilleure pratique que je devrais connaître? Aurais-je dû écrire un démon à la place?

Plusieurs programmes automatisent cette fonctionnalité, éliminent la gêne et les bugs potentiels, et évitent le problème de verrouillage obsolète en utilisant également flock dans les coulisses (ce qui présente un risque si vous utilisez uniquement le toucher). . J'ai déjà utilisé lockrunet lckdodans le passé, mais maintenant il y a flock(1) (dans les nouvelles versions d'util-linux), ce qui est génial. C'est vraiment facile à utiliser:

* * * * * /usr/bin/flock -n /tmp/fcj.lockfile /usr/local/bin/frequent_cron_job

Le meilleur moyen en shell est d'utiliser flock (1)

(
  flock -x -w 5 99
  ## Do your stuff here
) 99>/path/to/my.lock

En fait, flock -npeut être utilisé à la place de lckdo*, vous utiliserez donc le code des développeurs du noyau.

En vous basant sur l'exemple de womble , vous écririez quelque chose comme:

* * * * * flock -n /some/lockfile command_to_run_every_minute

BTW, regardant le code, tous flock, lockrunet lckdofaire exactement la même chose, il est donc juste une question de ce qui est plus facilement disponible pour vous.

Vous pouvez utiliser un fichier de verrouillage. Créez ce fichier au démarrage du script et supprimez-le à la fin. Avant d'exécuter sa routine principale, le script doit vérifier si le fichier de verrouillage existe et procéder en conséquence.

Les fichiers de verrouillage sont utilisés par les scripts d'initialisation et par de nombreuses autres applications et utilitaires dans les systèmes Unix.

Vous n'avez pas spécifié si vous voulez que le script attende ou non l'exécution précédente. Par "Je ne veux pas que les travaux commencent à" s'empiler "les uns sur les autres", je suppose que vous sous-entendez que vous voulez que le script se ferme s'il est déjà en cours d'exécution,

Donc, si vous ne voulez pas dépendre de lckdo ou similaire, vous pouvez le faire:

PIDFILE=/tmp/`basename $0`.pid

if [ -f $PIDFILE ]; then
  if ps -p `cat $PIDFILE` > /dev/null 2>&1; then
      echo "$0 already running!"
      exit
  fi
fi
echo $$ > $PIDFILE

trap 'rm -f "$PIDFILE" >/dev/null 2>&1' EXIT HUP KILL INT QUIT TERM

# do the work

Cela pourrait également être un signe que vous faites la mauvaise chose. Si vos tâches sont exécutées aussi étroitement et aussi fréquemment, vous devriez peut-être envisager de la décoder et d'en faire un programme de type démon.

Votre démon cron ne devrait pas appeler des travaux si leurs instances précédentes sont toujours en cours d'exécution. Je suis le développeur d'un démon cron dcron , et nous essayons précisément d'empêcher cela. Je ne sais pas comment Vixie Cron ou d'autres démons gèrent cela.

Je recommanderais d'utiliser la commande run-one - beaucoup plus simple que de traiter avec les verrous. De la docs:

run-one est un script wrapper qui n'exécute pas plus d'une instance unique d'une commande avec un ensemble unique d'arguments. Ceci est souvent utile avec les tâches cron, lorsque vous ne voulez pas exécuter plus d’une copie à la fois.

run-this-one est exactement comme run-one, sauf qu'il utilisera pgrep et kill pour rechercher et tuer tous les processus en cours d'exécution détenus par l'utilisateur et correspondant aux commandes et arguments cibles. Notez que run-this-one bloquera tout en essayant de tuer les processus correspondants jusqu'à ce que tous les processus correspondants soient morts.

run-one- fonctionne exactement de la même manière que run-one, sauf qu'il rappelle "COMMAND [ARGS]" à chaque sortie de COMMAND (zéro ou différent de zéro).

Keep-one-running est un alias pour run-one-constamment.

run-one-Until-Success fonctionne exactement comme run-one-constant sauf qu'il rappelle "COMMAND [ARGS]" jusqu'à ce que COMMAND se ferme correctement (c.-à-d. qu'il quitte zéro).

run-one-jusqu'à-échec fonctionne exactement comme run-one-constamment, sauf qu'il rappelle "COMMAND [ARGS]" jusqu'à ce que COMMAND se termine avec un échec (c'est-à-dire des sorties différentes de zéro).

Maintenant que systemd est sorti, il existe un autre mécanisme de planification sur les systèmes Linux:

UNE systemd.timer

Dans /etc/systemd/system/myjob.serviceou ~/.config/systemd/user/myjob.service:

[Service]
ExecStart=/usr/local/bin/myjob

Dans /etc/systemd/system/myjob.timerou ~/.config/systemd/user/myjob.timer:

[Timer]
OnCalendar=minutely

[Install]
WantedBy=timers.target

Si l'unité de service est déjà activée lors de l'activation suivante du minuteur, une autre instance du service ne sera pas démarrée.

Une alternative, qui démarre le travail une fois au démarrage et une minute après la fin de chaque exécution:

[Timer]
OnBootSec=1m
OnUnitInactiveSec=1m 

[Install]
WantedBy=timers.target

J'ai créé un bocal pour résoudre un problème tel que les doublons de crons exécutés pourraient être java ou cron shell. Il suffit de passer le nom du cron dans Duplicates.CloseSessions ("Demo.jar") pour rechercher et tuer le pid existant pour ce cron, sauf current. J'ai mis en place une méthode pour faire ce genre de choses. Proname de chaîne = ManagementFactory.getRuntimeMXBean (). GetName (); String pid = proname.split ("@") [0]; System.out.println ("PID actuel:" + pid);

            Process proc = Runtime.getRuntime().exec(new String[]{"bash","-c"," ps aux | grep "+cronname+" | awk '{print $2}' "});

            BufferedReader stdInput = new BufferedReader(new InputStreamReader(proc.getInputStream()));
            String s = null;
            String killid="";

            while ((s = stdInput.readLine()) != null ) {                                        
                if(s.equals(pid)==false)
                {
                    killid=killid+s+" ";    
                }
            }

Et puis tuez la chaîne killid avec à nouveau la commande shell

@Philip Reynolds answer commencera à exécuter le code après le délai d’attente de 5 secondes sans obtenir le verrou. Après Flock ne semble pas fonctionner, j'ai modifié la réponse de @Philip Reynolds à

(
  flock -w 5 -x 99 || exit 1
  ## Do your stuff here
) 99>/path/to/my.lock

afin que le code ne soit jamais exécuté simultanément. Au lieu de cela, après 5 secondes d’attente, le processus se termine avec 1 s’il n’a pas encore obtenu le verrou.