Esecuzione di un loop esattamente una volta al secondo

Sto eseguendo questo ciclo per controllare e stampare alcune cose ogni secondo. Tuttavia, poiché i calcoli richiedono forse alcune centinaia di millisecondi, il tempo stampato a volte salta un secondo.

Esiste un modo per scrivere un ciclo tale che mi viene garantito di ottenere una stampa ogni secondo? (A condizione, ovviamente, che i calcoli nel ciclo richiedano meno di un secondo :))

while true; do
  TIME=$(date +%H:%M:%S)
  # some calculations which take a few hundred milliseconds
  FOO=...
  BAR=...
  printf '%s  %s  %s\n' $TIME $FOO $BAR
  sleep 1
done

Per stare un po 'più vicino al codice originale, quello che faccio è:

while true; do
  sleep 1 &
  ...your stuff here...
  wait # for sleep
done

Questo cambia un po 'la semantica: se le tue cose impiegano meno di un secondo, aspetteranno semplicemente che passi il secondo intero. Tuttavia, se le tue cose impiegano più di un secondo per qualsiasi motivo, non continueranno a generare ancora più sottoprocessi senza mai finire.

Quindi le tue cose non funzionano mai in parallelo, e non in background, quindi anche le variabili funzionano come previsto.

Nota che se avvii anche attività in background aggiuntive, dovrai modificare le waitistruzioni per attendere solo il sleepprocesso in modo specifico.

Se ne hai bisogno per essere ancora più preciso, probabilmente dovrai solo sincronizzarlo con l'orologio di sistema e sleep ms invece di secondi interi.

Come sincronizzare l'orologio di sistema? Nessuna idea davvero, stupido tentativo:

Predefinito:

while sleep 1
do
    date +%N
done

Uscita: 003511461 010510925 016081282 021643477 028504349 03 ... (continua a crescere)

sincronizzato:

 while sleep 0.$((1999999999 - 1$(date +%N)))
 do
     date +%N
 done

Uscita: 002648691 001098397 002514348 001293023 001679137 00 ... (rimane uguale)

Se riesci a ristrutturare il tuo loop in uno script / oneliner, il modo più semplice per farlo è con watche la sua preciseopzione.

Puoi vedere l'effetto con watch -n 1 sleep 0.5: mostrerà i secondi contando, ma occasionalmente salterà più di un secondo. Eseguendolo come watch -n 1 -p sleep 0.5verrà emesso due volte al secondo, ogni secondo e non vedrai alcun salto.

L'esecuzione delle operazioni in una subshell che viene eseguita come processo in background impedirebbe loro di interferire con il sleep.

while true; do
  (
    TIME=$(date +%T)
    # some calculations which take a few hundred milliseconds
    FOO=...
    BAR=...
    printf '%s  %s  %s\n' "$TIME" "$FOO" "$BAR"
  ) &
  sleep 1
done

L'unica volta "rubata" da un secondo sarebbe il tempo impiegato per lanciare la subshell, quindi alla fine salterebbe un secondo, ma si spera meno spesso del codice originale.

Se il codice nella subshell finisce per usare più di un secondo, il ciclo inizierà ad accumulare lavori in background e alla fine esaurire le risorse.

Un'altra alternativa (se non è possibile utilizzare, ad esempio, watch -pcome suggerisce Maelstrom) è sleepenh[ manpage ], che è progettato per questo.

Esempio:

#!/bin/sh

t=$(sleepenh 0)
while true; do
        date +'sec=%s ns=%N'
        sleep 0.2
        t=$(sleepenh $t 1)
done

Si noti sleep 0.2che il simulatore esegue un compito dispendioso in termini di tempo, consumando circa 200 ms. Nonostante ciò, l'output dei nanosecondi rimane stabile (beh, secondo gli standard del sistema operativo non in tempo reale) - succede una volta al secondo:

sec=1533663406 ns=840039402
sec=1533663407 ns=840105387
sec=1533663408 ns=840380678
sec=1533663409 ns=840175397
sec=1533663410 ns=840132883
sec=1533663411 ns=840263150
sec=1533663412 ns=840246082
sec=1533663413 ns=840259567
sec=1533663414 ns=840066687

Questo è diverso da 1 ms e nessuna tendenza. Va abbastanza bene; dovresti aspettarti un rimbalzo di almeno 10 ms se c'è un carico sul sistema, ma nel tempo non c'è alcuna deriva. Cioè, non perderai un secondo.

Con zsh:

n=0
typeset -F SECONDS=0
while true; do
  date '+%FT%T.%2N%z'
  ((++n > SECONDS)) && sleep $((n - SECONDS))
done

Se il sonno non supporta floating point secondi, è possibile utilizzare zshl' zselectinvece (dopo una zmodload zsh/zselect):

zmodload zsh/zselect
n=0
typeset -F SECONDS=0
while true; do
  date '+%FZ%T.%2N%z'
  ((++n > SECONDS)) && zselect -t $((((n - SECONDS) * 100) | 0))
done

Questi non devono andare alla deriva finché i comandi nel loop impiegano meno di un secondo per l'esecuzione.

Avevo esattamente lo stesso requisito per uno script di shell POSIX, in cui tutti gli helper (usleep, GNUsleep, sleepenh, ...) non erano disponibili.

vedi: https://stackoverflow.com/a/54494216

#!/bin/sh

get_up()
{
        read -r UP REST </proc/uptime
        export UP=${UP%.*}${UP#*.}
}

wait_till_1sec_is_full()
{
    while true; do
        get_up
        test $((UP-START)) -ge 100 && break
    done
}

while true; do
    get_up; START=$UP

    your_code

    wait_till_1sec_is_full
done