Unikanie zajętego czekania w mgnieniu oka, bez komendy uśpienia

Wiem, że mogę czekać na spełnienie warunku bash, wykonując:

while true; do
  test_condition && break
  sleep 1
done

Ale tworzy 1 podproces przy każdej iteracji (uśpieniu). Mogłem ich uniknąć, wykonując:

while true; do
  test_condition && break
done

Ale zużywa dużo procesora (zajęte oczekiwanie). Aby uniknąć podprocesów i zajętego czekaniem, wymyśliłem poniższe rozwiązanie, ale wydaje mi się brzydkie:

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.

Uwaga: w ogólnym przypadku nie mogę po prostu użyć read -t 1 varbez fifo, ponieważ zużyje standardowe wejście i nie będzie działać, jeśli standardowe wejście nie jest terminalem ani rurą.

Czy mogę uniknąć podprocesów i zajętego oczekiwania w bardziej elegancki sposób?

W nowszych wersjach bash(przynajmniej v2) wbudowane mogą być ładowane (przez enable -f filename commandname) w czasie wykonywania. Wiele takich ładowalnych wbudowanych plików jest również dystrybuowanych ze źródłami bash i sleepjest wśród nich. Oczywiście dostępność może się różnić w zależności od systemu operacyjnego (a nawet komputera). Na przykład w openSUSE te wbudowane funkcje są dystrybuowane za pośrednictwem pakietu bash-loadables.

Edycja: napraw nazwę pakietu, dodaj minimalną wersję bash.

Tworzenie wielu podprocesów jest złą rzeczą w wewnętrznej pętli. Tworzenie jednego sleepprocesu na sekundę jest OK. Nie ma w tym nic złego

while ! test_condition; do
  sleep 1
done

Jeśli naprawdę chcesz uniknąć zewnętrznego procesu, nie musisz utrzymywać otwartego 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

Ostatnio musiałem to zrobić. Wymyśliłem następującą funkcję, która pozwoli bashowi spać na zawsze bez wywoływania jakiegokolwiek programu zewnętrznego:

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

UWAGA: Wcześniej opublikowałem wersję, która za każdym razem otwierałaby i zamykała deskryptor pliku, ale zauważyłem, że w niektórych systemach, robiąc to setki razy, sekunda w końcu się blokuje. Zatem nowe rozwiązanie utrzymuje deskryptor pliku między wywołaniami funkcji. Bash i tak wyczyści go przy wyjściu.

Można to nazwać tak jak / bin / sleep i będzie ono spało przez żądany czas. Wywołany bez parametrów, zawiesi się na zawsze.

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

Tutaj jest mój blog z nadmiernymi szczegółami

W ksh93lub mksh, sleepjest wbudowane powłoki, tak Alternatywą może być zastosowanie tych skorup, a nie bash.

zshma również zselectwbudowane (ładowane zmodload zsh/zselect), które mogą spać przez określoną liczbę setnych sekund z zselect -t <n>.

Jak powiedział użytkownik yoi , jeśli w twoim skrypcie jest otwarte stdin , to zamiast uśpienia 1 możesz po prostu użyć:

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

W wersji Bash 4.1 i nowszych możesz użyć liczby zmiennoprzecinkowej, np read -t 0.3 ...

Jeśli w skrypcie stdin jest zamknięte (skrypt jest wywoływany my_script.sh < /dev/null &), musisz użyć innego otwartego deskryptora, który nie generuje danych wyjściowych po wykonaniu odczytu , np. standardowe :

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

Jeśli w skrypcie cały deskryptor jest zamknięty ( stdin , stdout , stderr ) (np. Ponieważ jest wywoływany jako demon), to musisz znaleźć dowolny plik, który nie generuje danych wyjściowych:

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

Działa to zarówno z powłoki logowania, jak i powłoki nieinteraktywnej.

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

Czy naprawdę potrzebujesz fifo? Powinno również działać przekierowanie standardowego wejścia na inny deskryptor pliku.

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

Inspirowane przez: Przeczytaj dane wejściowe w bash w pętli while

Nieznaczna poprawa wyżej wymienionych rozwiązań (na których to oparłem).

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

# sleep for 10 seconds
bash_sleep 10

Zmniejszyło potrzebę użycia fifo, a zatem nie ma potrzeby sprzątania.