Comment faire en sorte qu'un script unix s'exécute toutes les 15 secondes?

Question

J'ai vu quelques solutions, y compris regarder et exécuter simplement un script en boucle (et en veille) en arrière-plan, mais rien n'a été idéal.

J'ai un script qui doit être exécuté toutes les 15 secondes, et comme cron ne prend pas en charge les secondes, je suis obligé de trouver autre chose.

Quel est le moyen le plus efficace et le plus efficace d’exécuter un script toutes les 15 secondes sous Unix? Le script doit également être exécuté après un redémarrage.

Answer 1

J'utiliserais cron pour exécuter un script toutes les minutes et lui demander d'exécuter votre script quatre fois avec une pause de 15 secondes entre les exécutions.

(Cela suppose que votre script est rapide à exécuter - vous pouvez ajuster les heures de veille si ce n'est pas le cas.)

Ainsi, vous bénéficiez de tous les avantages de cron ainsi que de votre période d'exécution de 15 secondes.

Modifier: Voir également le commentaire de @ bmb ci-dessous.

Answer 2

Si vous insistez pour exécuter votre script à partir de cron:

* * * * * /foo/bar/your_script
* * * * * sleep 15; /foo/bar/your_script
* * * * * sleep 30; /foo/bar/your_script
* * * * * sleep 45; /foo/bar/your_script

et remplacez votre nom de script et votre chemin d'accès vers / foo / bar / your_script

Answer 3

Version modifiée de ce qui précède:

mkdir /etc/cron.15sec
mkdir /etc/cron.minute
mkdir /etc/cron.5minute

ajouter à / etc / crontab:

* * * * * root run-parts /etc/cron.15sec > /dev/null 2> /dev/null
* * * * * root sleep 15; run-parts /etc/cron.15sec > /dev/null 2> /dev/null
* * * * * root sleep 30; run-parts /etc/cron.15sec > /dev/null 2> /dev/null
* * * * * root sleep 45; run-parts /etc/cron.15sec > /dev/null 2> /dev/null

* * * * * root run-parts /etc/cron.minute > /dev/null 2> /dev/null
*/5 * * * * root run-parts /etc/cron.5minute > /dev/null 2> /dev/null

Answer 4

Vous ne voulez pas exécuter ceci en arrière-plan?

#!/bin/sh
while [ 1 ]; do
    echo "Hell yeah!" &
    sleep 15
done

C’est aussi efficace que possible. La partie importante n’est exécutée que toutes les 15 secondes et le script s’endort le reste du temps (sans gaspillage de cycles).

Answer 5

J'ai écrit un planificateur plus rapide que cron. J'ai également mis en place une garde qui se chevauchent. Vous pouvez configurer le planificateur pour ne pas démarrer un nouveau processus si le précédent est toujours en cours d'exécution. Consultez https://github.com/sioux1977/scheduler/wiki

Answer 6

Utilisez nanosleep (2) . Il utilise la structure timespec utilisée pour spécifier des intervalles de temps avec une précision à la nanoseconde.

struct timespec {
           time_t tv_sec;        /* seconds */
           long   tv_nsec;       /* nanoseconds */
       };

Answer 7

#! /bin/sh

# Run all programs in a directory in parallel
# Usage: run-parallel directory delay
# Copyright 2013 by Marc Perkel
# docs at http://wiki.junkemailfilter.com/index.php/How_to_run_a_Linux_script_every_few_seconds_under_cron"
# Free to use with attribution

if [ $# -eq 0 ]
then
   echo
   echo "run-parallel by Marc Perkel"
   echo
   echo "This program is used to run all programs in a directory in parallel" 
   echo "or to rerun them every X seconds for one minute."
   echo "Think of this program as cron with seconds resolution."
   echo
   echo "Usage: run-parallel [directory] [delay]"
   echo
   echo "Examples:"
   echo "   run-parallel /etc/cron.20sec 20"
   echo "   run-parallel 20"
   echo "   # Runs all executable files in /etc/cron.20sec every 20 seconds or 3 times a minute."
   echo 
   echo "If delay parameter is missing it runs everything once and exits."
   echo "If only delay is passed then the directory /etc/cron.[delay]sec is assumed."
   echo
   echo 'if "cronsec" is passed then it runs all of these delays 2 3 4 5 6 10 12 15 20 30'
   echo "resulting in 30 20 15 12 10 6 5 4 3 2 executions per minute." 
   echo
   exit
fi

# If "cronsec" is passed as a parameter then run all the delays in parallel

if [ $1 = cronsec ]
then
   <*> 2 &
   <*> 3 &
   <*> 4 &
   <*> 5 &
   <*> 6 &
   <*> 10 &
   <*> 12 &
   <*> 15 &
   <*> 20 &
   <*> 30 &
   exit
fi

# Set the directory to first prameter and delay to second parameter

dir=$1
delay=$2

# If only parameter is 2,3,4,5,6,10,12,15,20,30 then automatically calculate 
# the standard directory name /etc/cron.[delay]sec

if [[ "$1" =~ ^(2|3|4|5|6|10|12|15|20|30)$ ]]
then
   dir="/etc/cron.$1sec"
   delay=$1
fi

# Exit if directory doesn't exist or has no files

if [ ! "$(ls -A $dir/)" ]
then
   exit
fi

# Sleep if both $delay and $counter are set

if [ ! -z $delay ] && [ ! -z $counter ]
then
   sleep $delay
fi

# Set counter to 0 if not set

if [ -z $counter ]
then
   counter=0
fi

# Run all the programs in the directory in parallel
# Use of timeout ensures that the processes are killed if they run too long

for program in $dir/* ; do
   if [ -x $program ] 
   then
      if [ "0$delay" -gt 1 ] 
      then
         timeout $delay $program &> /dev/null &
      else
         $program &> /dev/null &
      fi
   fi
done

# If delay not set then we're done

if [ -z $delay ]
then
   exit
fi

# Add delay to counter

counter=$(( $counter + $delay ))

# If minute is not up - call self recursively

if [ $counter -lt 60 ]
then
   . <*> $dir $delay &
fi

# Otherwise we're done

Answer 8

Depuis ma réponse précédente, j'ai proposé une autre solution différente et peut-être meilleure. Ce code permet aux processus d'être exécutés plus de 60 fois par minute avec une précision de l'ordre de la microseconde. Vous avez besoin du programme usleep pour que cela fonctionne. Devrait être bon jusqu'à 50 fois par seconde.

#! /bin/sh

# Microsecond Cron
# Usage: cron-ms start
# Copyright 2014 by Marc Perkel
# docs at http://wiki.junkemailfilter.com/index.php/How_to_run_a_Linux_script_every_few_seconds_under_cron"
# Free to use with attribution

basedir=/etc/cron-ms

if [ $# -eq 0 ]
then
   echo
   echo "cron-ms by Marc Perkel"
   echo
   echo "This program is used to run all programs in a directory in parallel every X times per minute."
   echo "Think of this program as cron with microseconds resolution."
   echo
   echo "Usage: cron-ms start"
   echo
   echo "The scheduling is done by creating directories with the number of"
   echo "executions per minute as part of the directory name."
   echo
   echo "Examples:"
   echo "  /etc/cron-ms/7      # Executes everything in that directory  7 times a minute"
   echo "  /etc/cron-ms/30     # Executes everything in that directory 30 times a minute"
   echo "  /etc/cron-ms/600    # Executes everything in that directory 10 times a second"
   echo "  /etc/cron-ms/2400   # Executes everything in that directory 40 times a second"
   echo
   exit
fi

# If "start" is passed as a parameter then run all the loops in parallel
# The number of the directory is the number of executions per minute
# Since cron isn't accurate we need to start at top of next minute

if [ $1 = start ]
then
   for dir in $basedir/* ; do
      <*> ${dir##*/} 60000000 &
   done
   exit
fi

# Loops per minute and the next interval are passed on the command line with each loop

loops=$1
next_interval=$2

# Sleeps until a specific part of a minute with microsecond resolution. 60000000 is full minute

usleep $(( $next_interval - 10#$(date +%S%N) / 1000 ))

# Run all the programs in the directory in parallel

for program in $basedir/$loops/* ; do
   if [ -x $program ] 
   then
      $program &> /dev/null &
   fi
done

# Calculate next_interval

next_interval=$(($next_interval % 60000000 + (60000000 / $loops) ))

# If minute is not up - call self recursively

if [ $next_interval -lt $(( 60000000 / $loops * $loops)) ]
then
   . <*> $loops $next_interval &
fi

# Otherwise we're done

Answer 9

Pour éviter tout chevauchement d'exécution, utilisez un mécanisme de verrouillage tel que décrit dans ce document: thread .