Evitar ocupados esperando en bash, sin el comando sleep

Sé que puedo esperar que una condición se haga realidad en bash haciendo:

while true; do
  test_condition && break
  sleep 1
done

Pero crea 1 subproceso en cada iteración (suspensión). Podría evitarlos haciendo:

while true; do
  test_condition && break
done

Pero usa mucha CPU (espera ocupada). Para evitar subprocesos y esperas ocupadas, se me ocurrió la solución a continuación, pero me parece fea:

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.

Nota: en el caso general, no puedo simplemente usarlo read -t 1 varsin el fifo, porque consumirá stdin y no funcionará si stdin no es un terminal o una tubería.

¿Puedo evitar los subprocesos y la espera ocupada de una manera más elegante?

En las versiones más recientes de bash(al menos v2), los builtins se pueden cargar (vía enable -f filename commandname) en tiempo de ejecución. Un número de tales construcciones cargables también se distribuye con las fuentes bash, y se sleepencuentra entre ellas. La disponibilidad puede variar de un sistema operativo a otro (e incluso de máquina a máquina), por supuesto. Por ejemplo, en openSUSE, estos componentes internos se distribuyen a través del paquete bash-loadables.

Editar: arregle el nombre del paquete, agregue la versión mínima de bash.

Crear muchos subprocesos es algo malo en un bucle interno. Crear un sleepproceso por segundo está bien. No hay nada malo con

while ! test_condition; do
  sleep 1
done

Si realmente desea evitar el proceso externo, no necesita mantener abierto el Fifo.

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

Recientemente tuve la necesidad de hacer esto. Se me ocurrió la siguiente función que permitirá que bash duerma para siempre sin llamar a ningún programa externo:

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 || :
}

NOTA: Publiqué previamente una versión de esto que abriría y cerraría el descriptor de archivo cada vez, pero descubrí que en algunos sistemas que lo hacen cientos de veces por segundo eventualmente se bloqueará. Por lo tanto, la nueva solución mantiene el descriptor de archivo entre llamadas a la función. Bash lo limpiará a la salida de todos modos.

Esto se puede llamar como / bin / sleep, y se dormirá durante el tiempo solicitado. Llamado sin parámetros, se colgará para siempre.

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

Hay una reseña con detalles excesivos en mi blog aquí.

En ksh93o mksh, sleephay una concha incorporada, por lo que una alternativa podría ser usar esas conchas en lugar de bash.

zshtambién tiene un zselectincorporado (cargado con zmodload zsh/zselect) que puede dormir durante un número determinado de centésimas de segundo con zselect -t <n>.

Como dijo el usuario yoi , si en su script se abre stdin , entonces en lugar de dormir 1 simplemente puede usar:

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

En Bash versión 4.1 y posteriores, puede usar el número flotante, p. Ej. read -t 0.3 ...

Si en un script, stdin está cerrado (se llama script my_script.sh < /dev/null &), entonces necesita usar otro descriptor abierto, que no produce salida cuando se ejecuta la lectura , por ejemplo. stdout :

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

Si en un script todo el descriptor está cerrado ( stdin , stdout , stderr ) (por ejemplo, porque se llama como daemon), entonces necesita encontrar cualquier archivo existente que no produzca resultados:

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

Esto funciona desde un shell de inicio de sesión, así como desde un shell no interactivo.

#!/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

¿Realmente necesitas un quince? Redirigir stdin a otro descriptor de archivo también debería funcionar.

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

Inspirado por: Leer la entrada en bash dentro de un bucle while

Una ligera mejora en las soluciones mencionadas anteriormente (en las que he basado esto).

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

# sleep for 10 seconds
bash_sleep 10

Se redujo la necesidad de un fifo y, por lo tanto, no hay que limpiar.