특정 시간 / 날짜까지 수면

Question 1

내 bash 스크립트가 특정 시간까지 잠자기를 원합니다. 그래서 저는 "sleep"과 같은 명령을 원합니다.이 명령은 간격이 걸리지 않고 종료 시간이 걸리고 그때까지 잠을 잔다.

특정 날짜 / 시간까지 실행중인 스크립트를 차단해야하므로 "at"데몬은 해결책이 아닙니다.

그런 명령이 있습니까?

Question 2

Outlaw Programmer가 언급했듯이 해결책은 정확한 시간 (초) 동안 수면을 취하는 것입니다.

bash에서이를 수행하려면 다음을 수행하십시오.

current_epoch=$(date +%s)
target_epoch=$(date -d '01/01/2010 12:00' +%s)

sleep_seconds=$(( $target_epoch - $current_epoch ))

sleep $sleep_seconds

나노초 (효과적으로 약 밀리 초 정도)까지 정밀도를 추가하려면 다음 구문을 사용하십시오.

current_epoch=$(date +%s.%N)
target_epoch=$(date -d "20:25:00.12345" +%s.%N)

sleep_seconds=$(echo "$target_epoch - $current_epoch"|bc)

sleep $sleep_seconds

참고 맥 OS / OS X 초 이하의 정밀도를 지원하지 않습니다, 당신은 사용해야합니다 coreutils에서 brew→ 대신에 이 지침을 참조하십시오

Question 3

이 질문은 4 년 전에 질문 되었으므로이 첫 번째 부분은 이전 bash 버전에 관한 것입니다.

마지막 수정 : 2020 년 4 월 22 일 수요일, 10:30에서 10h : 55 사이 (샘플 읽기에 중요)

일반적인 방법 (쓸모없는 포크는 피하십시오!)

(참고 :이 방법 date -f은 POSIX가 아니고 MacOS에서는 작동하지 않습니다! Mac에서는 my pure세게 때리다기능 )

줄이기 위해 두 번 forks실행하는 대신 다음 date을 사용하는 것이 좋습니다.

간단한 시작 샘플

sleep $(($(date -f - +%s- <<< $'tomorrow 21:30\nnow')0))

위치를 tomorrow 21:30인식 날짜와 형식의 모든 종류로 대체 될 수있는 date미래에.

고정밀 (nanosec)

거의 동일 :

sleep $(bc <<<s$(date -f - +'t=%s.%N;' <<<$'07:00 tomorrow\nnow')'st-t')

다음에 도달

가능한 경우 오늘 다음HH:MM 의미 에 도달 하고 너무 늦으면 내일 :

sleep $((($(date -f - +%s- <<<$'21:30 tomorrow\nnow')0)%86400))

이것은 아래에서 작동합니다 세게 때리다, ksh 그리고 다른 현대적인 셸을 사용해야하지만 다음을 사용해야합니다.

sleep $(( ( $(printf 'tomorrow 21:30\nnow\n' | date -f - +%s-)0 )%86400 ))

가벼운 껍질 아래에서금연 건강 증진 협회 또는 대시.

순수한 세게 때리다 방법, 포크 없음 !!

MacOS에서 테스트되었습니다!

내가 쓴 한 두 개의 작은 기능 : sleepUntil및sleepUntilHires

 Syntax:
 sleepUntil [-q] <HH[:MM[:SS]]> [more days]
     -q Quiet: don't print sleep computed argument
     HH          Hours (minimal required argument)
     MM          Minutes (00 if not set)
     SS          Seconds (00 if not set)
     more days   multiplied by 86400 (0 by default)

새로운 버전의 bash는 printf날짜를 검색 하는 옵션을 제공하므로 HH : MM까지date 또는 다른 포크를 사용 하지 않을 때까지 잠자기 위한이 새로운 방법을 위해 약간을 빌드했습니다.세게 때리다함수. 여기있어:

sleepUntil() { # args [-q] <HH[:MM[:SS]]> [more days]
    local slp tzoff now quiet=false
    [ "$1" = "-q" ] && shift && quiet=true
    local -a hms=(${1//:/ })
    printf -v now '%(%s)T' -1
    printf -v tzoff '%(%z)T\n' $now
    tzoff=$((0${tzoff:0:1}(3600*${tzoff:1:2}+60*${tzoff:3:2})))
    slp=$((
       ( 86400+(now-now%86400) + 10#$hms*3600 + 10#${hms[1]}*60 + 
         ${hms[2]}-tzoff-now ) %86400 + ${2:-0}*86400
    ))
    $quiet || printf 'sleep %ss, -> %(%c)T\n' $slp $((now+slp))
    sleep $slp
}

그때:

sleepUntil 10:37 ; date +"Now, it is: %T"
sleep 49s, -> Wed Apr 22 10:37:00 2020
Now, it is: 10:37:00

sleepUntil -q 10:37:44 ; date +"Now, it is: %T"
Now, it is: 10:37:44

sleepUntil 10:50 1 ; date +"Now, it is: %T"
sleep 86675s, -> Thu Apr 23 10:50:00 2020
^C

목표가 이전 이면 내일까지 잠자기 :

sleepUntil 10:30 ; date +"Now, it is: %T"
sleep 85417s, -> Thu Apr 23 10:30:00 2020
^C

sleepUntil 10:30 1 ; date +"Now, it is: %T"
sleep 171825s, -> Fri Apr 24 10:30:00 2020
^C

HiRes 시간 세게 때리다 GNU / Linux에서

충적세 세게 때리다, 버전 5.0에서 $EPOCHREALTIME마이크로 초로 새 변수를 추가 합니다. 이것으로부터 sleepUntilHires기능이 있습니다.

sleepUntilHires () { # args [-q] <HH[:MM[:SS]]> [more days]
    local slp tzoff now quiet=false musec musleep;
    [ "$1" = "-q" ] && shift && quiet=true;
    local -a hms=(${1//:/ });
    printf -v now '%(%s)T' -1;
    IFS=. read now musec <<< $EPOCHREALTIME;
    musleep=$[2000000-10#$musec];
    printf -v tzoff '%(%z)T\n' $now;
    tzoff=$((0${tzoff:0:1}(3600*${tzoff:1:2}+60*${tzoff:3:2})));
    slp=$(((( 86400 + ( now - now%86400 ) +
            10#$hms*3600+10#${hms[1]}*60+10#${hms[2]} -
            tzoff - now - 1
            ) % 86400 ) + ${2:-0} * 86400
          )).${musleep:1};
    $quiet || printf 'sleep %ss, -> %(%c)T\n' $slp $((now+${slp%.*}+1));
    read -t $slp foo
}

참고 :이 사용 read -t은 sleep. 불행히도 실제 TTY 없이는 백그라운드에서 실행할 때 작동하지 않습니다. 대체 자유롭게 read -t에 의해 sleep당신이 ... (하지만 백그라운드 프로세스에 대한 사용을 고려 배경 스크립트에서이 작업을 실행하려는 경우 cron및 / 또는 at그 대신 모든이의)

테스트 및 경고를 위해 다음 단락을 건너 뛰십시오 $ËPOCHSECONDS!

최근 커널 `/proc/timer_list`은 사용자가 사용하지 마십시오 !!

최근 Linux 커널에서는 ** nanoseconds **에서`offset`과`now` 변수를 읽을 수있는`/ proc / timer_list`라는 변수 파일을 찾을 수 있습니다. 따라서 우리는 * 매우 최고 * 원하는 시간에 도달하기 위해 수면 시간을 계산할 수 있습니다.

(1 초 동안 수천 줄을 포함하는 매우 큰 로그 파일에서 특정 이벤트를 생성하고 추적하기 위해 이것을 작성했습니다.)

mapfile  </proc/timer_list _timer_list
for ((_i=0;_i<${#_timer_list[@]};_i++));do
    [[ ${_timer_list[_i]} =~ ^now ]] && TIMER_LIST_SKIP=$_i
    [[ ${_timer_list[_i]} =~ offset:.*[1-9] ]] && \
    TIMER_LIST_OFFSET=${_timer_list[_i]//[a-z.: ]} && \
     break
done
unset _i _timer_list
readonly TIMER_LIST_OFFSET TIMER_LIST_SKIP

sleepUntilHires() {
    local slp tzoff now quiet=false nsnow nsslp
    [ "$1" = "-q" ] && shift && quiet=true
    local hms=(${1//:/ })
    mapfile -n 1 -s $TIMER_LIST_SKIP nsnow </proc/timer_list
    printf -v now '%(%s)T' -1
    printf -v tzoff '%(%z)T\n' $now
    nsnow=$((${nsnow//[a-z ]}+TIMER_LIST_OFFSET))
    nsslp=$((2000000000-10#${nsnow:${#nsnow}-9}))
    tzoff=$((0${tzoff:0:1}(3600*${tzoff:1:2}+60*${tzoff:3:2})))
    slp=$(( ( 86400 + ( now - now%86400 ) +
            10#$hms*3600+10#${hms[1]}*60+${hms[2]} -
            tzoff - now - 1
        ) % 86400)).${nsslp:1}
    $quiet || printf 'sleep %ss, -> %(%c)T\n' $slp $((now+${slp%.*}+1))
    sleep $slp
}

이 정의한 후 읽기 전용 변수를 TIMER_LIST_OFFSET하고 TIMER_LIST_SKIP, 함수는 매우 빠르게 변수 파일에 액세스 할 /proc/timer_list수면 시간을 계산하기 위해 :

작은 테스트 기능

tstSleepUntilHires () { 
    local now next last
    printf -v next "%(%H:%M:%S)T" $((${EPOCHREALTIME%.*}+1))
    sleepUntilHires $next
    date -f - +%F-%T.%N < <(echo now;sleep .92;echo now)
    printf -v next "%(%H:%M:%S)T" $((${EPOCHREALTIME%.*}+1))
    sleepUntilHires $next
    date +%F-%T.%N
}

다음과 같이 렌더링 할 수 있습니다.

sleep 0.244040s, -> Wed Apr 22 10:34:39 2020
2020-04-22-10:34:39.001685312
2020-04-22-10:34:39.922291769
sleep 0.077012s, -> Wed Apr 22 10:34:40 2020
2020-04-22-10:34:40.004264869

다음 초 초에
인쇄 시간, 다음
0.92 초를 기다린 다음
인쇄 시간, 다음
다음 초까지 남은 0.07 초 계산
0.07 초 수면 후
인쇄 시간.

케어는 혼합하지하기 `$EPOCHSECOND`와 `$EPOCHREALTIME`!

내 읽기 의 차이에 대한 경고 $EPOCHSECOND와$EPOCHREALTIME

이 함수는 다음 초 를 설정 $EPOCHREALTIME하는 데 사용하지 마십시오 .$EPOCHSECOND

샘플 문제 : 다음에 2 초 단위로 반올림 한 인쇄 시간 :

for i in 1 2;do
    printf -v nextH "%(%T)T" $(((EPOCHSECONDS/2)*2+2))
    sleepUntilHires $nextH
    IFS=. read now musec <<<$EPOCHREALTIME
    printf "%(%c)T.%s\n" $now $musec
done

생산 가능 :

sleep 0.587936s, -> Wed Apr 22 10:51:26 2020
Wed Apr 22 10:51:26 2020.000630
sleep 86399.998797s, -> Thu Apr 23 10:51:26 2020
^C

Question 4

를 사용 sleep하되를 사용하여 시간을 계산합니다 date. date -d이것을 사용하고 싶을 것 입니다. 예를 들어 다음 주까지 기다렸다 고 가정 해 보겠습니다.

expr `date -d "next week" +%s` - `date -d "now" +%s`

"다음 주"를 기다릴 날짜로 대체 한 다음이 표현식을 값에 할당하고 몇 초 동안 잠자기 만하면됩니다.

startTime=$(date +%s)
endTime=$(date -d "next week" +%s)
timeToWait=$(($endTime- $startTime))
sleep $timeToWait

다 했어요!

Question 5

다음은 작업을 수행하고 사용자에게 남은 시간을 알려주는 솔루션입니다. 나는 밤에 스크립트를 실행하기 위해 거의 매일 사용합니다 ( cron창에서 작업 할 수 없었기 때문에 cygwin 사용 )

풍모

초까지 정밀함
시스템 시간 변화를 감지하고 적응
남은 시간을 알려주는 지능형 출력
24 시간 입력 형식
연결할 수 있도록 true를 반환합니다. &&

샘플 실행

$ til 13:00 && date
1 hour and 18 minutes and 26 seconds left...
1 hour and 18 minutes left...
1 hour and 17 minutes left...
1 hour and 16 minutes left...
1 hour and 15 minutes left...
1 hour and 14 minutes left...
1 hour and 10 minutes left...
1 hour and  5 minutes left...
1 hour and  0 minutes left...
55 minutes left...
50 minutes left...
45 minutes left...
40 minutes left...
35 minutes left...
30 minutes left...
25 minutes left...
20 minutes left...
15 minutes left...
10 minutes left...
 5 minutes left...
 4 minutes left...
 3 minutes left...
 2 minutes left...
 1 minute left...
Mon, May 18, 2015  1:00:00 PM

(마지막 날짜는 함수의 일부가 아니지만 && date)

암호

til(){
  local hour mins target now left initial sleft correction m sec h hm hs ms ss showSeconds toSleep
  showSeconds=true
  [[ $1 =~ ([0-9][0-9]):([0-9][0-9]) ]] || { echo >&2 "USAGE: til HH:MM"; return 1; }
  hour=${BASH_REMATCH[1]} mins=${BASH_REMATCH[2]}
  target=$(date +%s -d "$hour:$mins") || return 1
  now=$(date +%s)
  (( target > now )) || target=$(date +%s -d "tomorrow $hour:$mins")
  left=$((target - now))
  initial=$left
  while (( left > 0 )); do
    if (( initial - left < 300 )) || (( left < 300 )) || [[ ${left: -2} == 00 ]]; then
      # We enter this condition:
      # - once every 5 minutes
      # - every minute for 5 minutes after the start
      # - every minute for 5 minutes before the end
      # Here, we will print how much time is left, and re-synchronize the clock

      hs= ms= ss=
      m=$((left/60)) sec=$((left%60)) # minutes and seconds left
      h=$((m/60)) hm=$((m%60)) # hours and minutes left

      # Re-synchronise
      now=$(date +%s) sleft=$((target - now)) # recalculate time left, multiple 60s sleeps and date calls have some overhead.
      correction=$((sleft-left))
      if (( ${correction#-} > 59 )); then
        echo "System time change detected..."
        (( sleft <= 0 )) && return # terminating as the desired time passed already
        til "$1" && return # resuming the timer anew with the new time
      fi

      # plural calculations
      (( sec > 1 )) && ss=s
      (( hm != 1 )) && ms=s
      (( h > 1 )) && hs=s

      (( h > 0 )) && printf %s "$h hour$hs and "
      (( h > 0 || hm > 0 )) && printf '%2d %s' "$hm" "minute$ms"
      if [[ $showSeconds ]]; then
        showSeconds=
        (( h > 0 || hm > 0 )) && (( sec > 0 )) && printf %s " and "
        (( sec > 0 )) && printf %s "$sec second$ss"
        echo " left..."
        (( sec > 0 )) && sleep "$sec" && left=$((left-sec)) && continue
      else
        echo " left..."
      fi
    fi
    left=$((left-60))
    sleep "$((60+correction))"
    correction=0
  done
}

Question 6

SIGSTOP 신호를 보내 프로세스 실행을 중지 한 다음 SIGCONT 신호를 보내 실행을 재개 할 수 있습니다.

따라서 SIGSTOP을 전송하여 스크립트를 중지 할 수 있습니다.

kill -SIGSTOP <pid>

그런 다음 at deamon을 사용하여 동일한 방식으로 SIGCONT를 전송하여 깨우십시오.

아마도 스크립트는 잠자기 전에 깨어나기를 원할 때 알려줄 것입니다.

Question 7

Ubuntu 12.04.4 LTS에서 작동하는 간단한 bash 입력은 다음과 같습니다.

sleep $(expr `date -d "03/21/2014 12:30" +%s` - `date +%s`)

Question 8

SpoonMeiser의 답변을 따르기 위해 다음은 구체적인 예입니다.

$cat ./reviveself

#!/bin/bash

# save my process ID
rspid=$$

# schedule my own resuscitation
# /bin/sh seems to dislike the SIGCONT form, so I use CONT
# at can accept specific dates and times as well as relative ones
# you can even do something like "at thursday" which would occur on a 
# multiple of 24 hours rather than the beginning of the day
echo "kill -CONT $rspid"|at now + 2 minutes

# knock myself unconscious
# bash is happy with symbolic signals
kill -SIGSTOP $rspid

# do something to prove I'm alive
date>>reviveself.out
$

Question 9

매일 같은 매개 변수로 스크립트를 실행할 수 있도록 시간과 분만 확인하는 스크립트를 원했습니다. 내일이 어느 날이 될지 걱정하고 싶지 않습니다. 그래서 저는 다른 접근 방식을 사용했습니다.

target="$1.$2"
cur=$(date '+%H.%M')
while test $target != $cur; do
    sleep 59
    cur=$(date '+%H.%M')
done

스크립트의 매개 변수는 시간과 분이므로 다음과 같이 작성할 수 있습니다.

til 7 45 && mplayer song.ogg

(til은 스크립트의 이름입니다)

직장에서 더 이상 늦게까지 일을 잘못 입력하지 않습니다. 건배!

Question 10

timeToWait = $ (($ end-$ start))

"timeToWait"는 음수 일 수 있습니다. (예를 들어 "15:57"까지 절전 모드로 지정하고 지금은 "15:58"로 지정하는 경우). 따라서 이상한 메시지 오류를 방지하기 위해 확인해야합니다.

#!/bin/bash
set -o nounset

### // Sleep until some date/time. 
# // Example: sleepuntil 15:57; kdialog --msgbox "Backup needs to be done."


error() {
  echo "$@" >&2
  exit 1;
}

NAME_PROGRAM=$(basename "$0")

if [[ $# != 1 ]]; then
     error "ERROR: program \"$NAME_PROGRAM\" needs 1 parameter and it has received: $#." 
fi


current=$(date +%s.%N)
target=$(date -d "$1" +%s.%N)

seconds=$(echo "scale=9; $target - $current" | bc)

signchar=${seconds:0:1}
if [ "$signchar" = "-" ]; then
     error "You need to specify in a different way the moment in which this program has to finish, probably indicating the day and the hour like in this example: $NAME_PROGRAM \"2009/12/30 10:57\"."
fi

sleep "$seconds"

# // End of file

Question 11

지금부터 깨우기 시간까지의 시간 (초)을 계산하고 기존 'sleep'명령을 사용할 수 있습니다.

Question 12

아마도 'at'를 사용하여 신호를 기다리는 스크립트에 신호를 보낼 수 있습니다.

Question 13

이 정확한 목적을 위해 실제로 https://tamentis.com/projects/sleepuntil/ 썼습니다 . 대부분의 코드는 BSD 'at'에서 온 것이므로 상당히 표준을 준수합니다.

$ sleepuntil noon && sendmail something

Question 14

다음은 여러 테스트 클라이언트를 동기화하기 위해 방금 작성한 내용입니다.

#!/usr/bin/python
import time
import sys

now = time.time()
mod = float(sys.argv[1])
until = now - now % mod + mod
print "sleeping until", until

while True:
    delta = until - time.time()
    if delta <= 0:
        print "done sleeping ", time.time()
        break
    time.sleep(delta / 2)

이 스크립트는 다음 "반올림"또는 "예리한"시간까지 휴면합니다.

간단한 사용 사례는 ./sleep.py 10; ./test_client1.py한 터미널과 ./sleep.py 10; ./test_client2.py다른 터미널에서 실행 하는 것 입니다.

Question 15

 function sleepuntil() {
  local target_time="$1"
  today=$(date +"%m/%d/%Y")
  current_epoch=$(date +%s)
  target_epoch=$(date -d "$today $target_time" +%s)
  sleep_seconds=$(( $target_epoch - $current_epoch ))

  sleep $sleep_seconds
}

target_time="11:59"; sleepuntil $target_time

Question 16

이를 위해 Hypnos 라는 작은 유틸리티 를 구성했습니다. crontab 구문을 사용하여 구성되고 그 때까지 차단됩니다.

#!/bin/bash
while [ 1 ]; do
  hypnos "0 * * * *"
  echo "running some tasks..."
  # ...
done

Question 17

주요 답변을 확장하기 위해 다음은 날짜 문자열 조작과 관련된 몇 가지 유효한 예입니다.

sleep $(($(date -f - +%s- <<< $'+3 seconds\nnow')0)) && ls

sleep $(($(date -f - +%s- <<< $'3 seconds\nnow')0)) && ls

sleep $(($(date -f - +%s- <<< $'3 second\nnow')0)) && ls

sleep $(($(date -f - +%s- <<< $'+2 minute\nnow')0)) && ls

sleep $(($(date -f - +%s- <<< $'tomorrow\nnow')0)) && ls

sleep $(($(date -f - +%s- <<< $'tomorrow 21:30\nnow')0)) && ls

sleep $(($(date -f - +%s- <<< $'3 weeks\nnow')0)) && ls

sleep $(($(date -f - +%s- <<< $'3 week\nnow')0)) && ls

sleep $(($(date -f - +%s- <<< $'next Friday 09:00\nnow')0)) && ls

sleep $(($(date -f - +%s- <<< $'2027-01-01 00:00:01 UTC +5 hours\nnow')0)) && ls

Question 18

에 오픈 BSD , 다음은 압축하는 데 사용할 수 있습니다 */55 분 crontab(5)에 작업 00(정확한 간격으로 동일한 작업을 수행하는 동안, 확실히 적은 이메일을 생성하는 모든를 만들기 위해) 시간당 하나를 :

#!/bin/sh -x
for k in $(jot 12 00 55)
  do
  echo $(date) doing stuff
  sleep $(expr $(date -j +%s $(printf %02d $(expr $k + 5))) - $(date -j +%s))
done

(가)주의 date(1)도를 깰 것 sleep(1)같은 최종 반복에 설계60 분은 유효 시간이 아닌 (이 경우를 제외하고는!), 따라서 우리는 우리의 이메일 보고서를 받고 이전에 여분의 시간을 기다릴 필요가 없습니다.

또한 반복 중 하나에 할당 된 시간이 5 분 이상 걸리면 sleep 에도 잠을 자지 않음으로써 설계에 의해 우아하게 실패 할 것입니다 (명령 줄 옵션으로 해석되는 음수이기 때문입니다. 다음 시간 또는 영원까지) 할당 된 시간 내에 작업을 완료 할 수 있는지 확인합니다 (예 : 반복 작업 중 하나만 5 분 이상 소요되는 경우). 다음 시간까지 포장되는 모든 것).

이 printf(1)필요하기 때문에 date기대하는 분 사양의 정확히 두 자리.

Question 19

tarry를 사용하십시오. 이 작업을 구체적으로 수행하기 위해 작성한 도구입니다.

https://github.com/metaphyze/tarry/

이것은 특정 시간까지 기다리는 간단한 명령 줄 도구입니다. 이것은 일정 시간 동안 대기하는 "sleep"과는 다릅니다. 이것은 특정 시간에 무언가를 실행하거나 서버가 여러 개의 매우 동시 요청을 처리 할 수 있는지 테스트하는 것과 같이 정확히 동시에 여러 가지를 실행하려는 경우에 유용합니다. Linux, Mac 또는 Windows에서 "&&"와 함께 다음과 같이 사용할 수 있습니다.

   tarry -until=16:03:04 && someOtherCommand

이것은 4:03:04 PM까지 기다린 다음 someOtherCommand를 실행합니다. 다음은 동시에 시작하도록 예약 된 여러 요청을 실행하는 방법에 대한 Linux / Mac 예입니다.

   for request in 1 2 3 4 5 6 7 8 9 10
   do
       tarry -until=16:03:04 && date > results.$request &
   done

Ubuntu, Linux 및 Windows 바이너리는 페이지의 링크를 통해 사용할 수 있습니다.