Éviter l'attente occupée dans bash, sans la commande sleep

Je sais que je peux attendre une condition pour devenir vrai en bash en faisant:

while true; do
  test_condition && break
  sleep 1
done

Mais il crée 1 sous-processus à chaque itération (sommeil). Je pourrais les éviter en faisant:

while true; do
  test_condition && break
done

Mais il utilise beaucoup de CPU (attente occupée). Pour éviter les sous-processus et les attentes occupées, j'ai trouvé la solution ci-dessous, mais je la trouve moche:

my_tmp_dir=$(mktemp -d --tmpdir=/tmp)    # Create a unique tmp dir for the fifo.
mkfifo $my_tmp_dir/fifo                  # Create an empty fifo for sleep by read.
exec 3<> $my_tmp_dir/fifo                # Open the fifo for reading and writing.

while true; do
  test_condition && break
  read -t 1 -u 3 var                     # Same as sleep 1, but without sub-process.
done

exec 3<&-                                # Closing the fifo.
rm $my_tmp_dir/fifo; rmdir $my_tmp_dir   # Cleanup, could be done in a trap.

Remarque: dans le cas général, je ne peux pas simplement utiliser read -t 1 varsans le fifo, car il consommera stdin et ne fonctionnera pas si stdin n'est pas un terminal ou un pipe.

Puis-je éviter les sous-processus et les attentes occupées de manière plus élégante?

Dans les versions plus récentes de bash(au moins v2), les commandes internes peuvent être chargées (via enable -f filename commandname) au moment de l'exécution. Un certain nombre de ces prédéfinis chargeables est également distribué avec les sources bash, et en sleepfait partie. La disponibilité peut différer d'un OS à l'autre (et même d'une machine à l'autre), bien sûr. Par exemple, sur openSUSE, ces commandes internes sont distribuées via le package bash-loadables.

Edit: correction du nom du package, ajout d'une version bash minimale.

La création d'un grand nombre de sous-processus est une mauvaise chose dans une boucle interne. Créer un sleepprocessus par seconde est OK. Il n'y a rien de mal à

while ! test_condition; do
  sleep 1
done

Si vous voulez vraiment éviter le processus externe, vous n'avez pas besoin de garder le fifo ouvert.

my_tmpdir=$(mktemp -d)
trap 'rm -rf "$my_tmpdir"' 0
mkfifo "$my_tmpdir/f"

while ! test_condition; do
  read -t 1 <>"$my_tmpdir/f"
done

J'ai récemment eu besoin de faire ça. J'ai proposé la fonction suivante qui permettra à bash de dormir indéfiniment sans appeler de programme externe:

snore()
{
    local IFS
    [[ -n "${_snore_fd:-}" ]] || { exec {_snore_fd}<> <(:); } 2>/dev/null ||
    {
        # workaround for MacOS and similar systems
        local fifo
        fifo=$(mktemp -u)
        mkfifo -m 700 "$fifo"
        exec {_snore_fd}<>"$fifo"
        rm "$fifo"
    }
    read ${1:+-t "$1"} -u $_snore_fd || :
}

REMARQUE: j'ai déjà publié une version de ceci qui ouvrirait et fermerait le descripteur de fichier à chaque fois, mais j'ai constaté que sur certains systèmes, le faire des centaines de fois par seconde finirait par se bloquer. Ainsi, la nouvelle solution conserve le descripteur de fichier entre les appels à la fonction. Bash le nettoiera quand même à la sortie.

Cela peut être appelé comme / bin / sleep, et il dormira pendant la durée demandée. Appelé sans paramètres, il se bloque pour toujours.

snore 0.1  # sleeps for 0.1 seconds
snore 10   # sleeps for 10 seconds
snore      # sleeps forever

Il y a un article avec des détails excessifs sur mon blog ici

Dans ksh93or mksh, sleepest un shell intégré, donc une alternative pourrait être d'utiliser ces shells à la place de bash.

zsha également un zselectintégré (chargé avec zmodload zsh/zselect) qui peut dormir pendant un nombre donné de centièmes de secondes avec zselect -t <n>.

Comme l' a dit l' utilisateur yoi , si dans votre script est ouvert stdin , alors au lieu de dormir 1, vous pouvez simplement utiliser:

read -t 1 3<&- 3<&0 <&3

Dans Bash version 4.1 et plus récente, vous pouvez utiliser un nombre flottant, par exemple read -t 0.3 ...

Si dans un script stdin est fermé (le script est appelé my_script.sh < /dev/null &), alors vous devez utiliser un autre descripteur ouvert, qui ne produit pas de sortie lorsque la lecture est exécutée, par exemple. stdout :

read -t 1 <&1 3<&- 3<&0 <&3

Si dans un script tous les descripteurs sont fermés ( stdin , stdout , stderr ) (par exemple parce qu'il est appelé comme démon), alors vous devez trouver tout fichier existant qui ne produit pas de sortie:

read -t 1 </dev/tty10 3<&- 3<&0 <&3

Cela fonctionne à partir d'un shell de connexion ainsi que d'un shell non interactif.

#!/bin/sh

# to avoid starting /bin/sleep each time we call sleep, 
# make our own using the read built in function
xsleep()
{
  read -t $1 -u 1
}

# usage
xsleep 3

Avez-vous vraiment besoin d'un fifo? La redirection de stdin vers un autre descripteur de fichier devrait également fonctionner.

{
echo line | while read line; do
   read -t 1 <&3
   echo "$line"
done
} 3<&- 3<&0

Inspiré par: Lire l'entrée dans bash à l'intérieur d'une boucle while

Une légère amélioration par rapport aux solutions mentionnées ci-dessus (sur lesquelles je me suis basé).

bash_sleep() {
    read -rt "${1?Specify sleep interval in seconds}" -u 1 <<<"" || :;
}

# sleep for 10 seconds
bash_sleep 10

Réduit le besoin d'un fifo et donc pas de nettoyage à faire.