Насколько точным является python time.sleep()?

Ответ 1

Точность функции time.sleep зависит от точности сна вашей базовой ОС. Для нереальной ОС, такой как стандартная Windows, наименьший интервал, в течение которого вы можете спать, составляет около 10-13 мс. Я видел точные сны в течение нескольких миллисекунд того времени, когда они превышали минимум 10-13 мс.

Обновление: Как упомянуто в документах, цитируемых ниже, обычно засыпать в цикле, который обязательно вернется ко сну, если он рано разбудит вас.

Я также должен отметить, что если вы работаете в Ubuntu, вы можете попробовать псевдо-ядро реального времени (с набором патчей RT_PREEMPT), установив пакет ядра rt (по крайней мере, в Ubuntu 10.04 LTS).

РЕДАКТИРОВАТЬ: Исправление ядра Linux не в реальном времени имеют минимальный интервал ожидания гораздо ближе к 1 мс, чем 10 мс, но он изменяется недетерминированным образом.

Ответ 2

Люди совершенно правы в отношении различий между операционными системами и ядрами, но я не вижу никакой детализации в Ubuntu, и я вижу гранулярность 1 мс в MS7. Предлагая другую реализацию time.sleep, а не только другую скорость тика. Более тщательная проверка предполагает, что в Ubuntu, между прочим, имеется зернистость 1μs, но это связано с функцией time.time, которую я использую для измерения точности.

Ответ 3

В документации :

С другой стороны, точность time() и sleep() лучше, чем их эквиваленты Unix: раз выраженные в виде чисел с плавающей запятой, time() возвращает наиболее точное время доступно (с использованием Unix gettimeofdayгде доступно), а sleep() - принять время с ненулевой фракцией (Unix select используется для реализации это, если доступно).

И более подробно w.r.t. sleep():

Приостановить выполнение для данного номера секунд. Аргументом может быть номер с плавающей запятой, чтобы указать более точное время сна. Настоящий время приостановки может быть меньше, чем это запрошен, потому что любой пойманный сигнал закончит sleep() следующее выполнение этих сигналов рутина. Кроме того, время приостановки может быть длиннее, чем запрашивается произвольной суммы из-за планирование другой деятельности в система.

Ответ 4

Почему бы вам не узнать:

from datetime import datetime
import time

def check_sleep(amount):
    start = datetime.now()
    time.sleep(amount)
    end = datetime.now()
    delta = end-start
    return delta.seconds + delta.microseconds/1000000.

error = sum(abs(check_sleep(0.050)-0.050) for i in xrange(100))*10
print "Average error is %0.2fms" % error

Для записи я обхожу около 0,1 мс ошибки на моем HTPC и 2 мс на моем ноутбуке, как на Linux-машинах.

Ответ 5

Здесь мое продолжение ответа Уилберта: то же самое для Mac OS X Yosemite, поскольку оно еще не упоминалось.

Похоже, что время, когда он спит примерно в 1,25 раза больше времени, которое вы запрашиваете, и иногда спит между 1 и 1,25 раза по времени, которое вы запрашиваете. Он почти никогда (~ дважды из 1000 образцов) спит значительно больше, чем в 1,25 раза больше, чем вы запрашиваете.

Также (не показано явно) соотношение 1.25 кажется довольно хорошим, пока вы не опуститесь ниже примерно на 0,2 мс, после чего он начнет немного размываться. Кроме того, фактическое время, по-видимому, опускается примерно на 5 мс дольше, чем вы запрашиваете, после того, как запрошенная величина времени превысит 20 мс.

Опять же, это выглядит совершенно другой реализацией sleep() в OS X, чем в Windows или в зависимости от того, какой Linux-сервер использовал Wilbert.

Ответ 6

Небольшая поправка, некоторые люди отмечают, что сон может быть прекращен рано по сигналу. В 3.6 документах сказано:

Изменено в версии 3.5: теперь функция спит не менее секунд, даже если спящий режим прерывается сигналом, за исключением случаев, когда обработчик сигнала вызывает исключение (объяснение см. В PEP 475).

Ответ 7

Вы не можете ничего гарантировать в отношении sleep(), за исключением того, что он, по крайней мере, приложит максимум усилий, чтобы спать, пока вы говорите об этом (сигналы могут убить ваш сон до истечения времени, и намного больше вещей может заставить его работать) долго).

Конечно, минимальный уровень, который вы можете получить в стандартной операционной системе настольного компьютера, составит около 16 мс (детализация таймера плюс время для переключения контекста), но есть вероятность, что отклонение в% от предоставленного аргумента будет значительным, когда вы пытаетесь спать в течение 10 секунд миллисекунд.

Сигналы, другие потоки, удерживающие GIL, удовольствие от планирования ядра, пошаговое изменение скорости процессора и т.д. - все это может повлиять на время, в течение которого ваш поток/процесс фактически спит.

Ответ 8

Протестировал это недавно на Python 3.7 на Windows 10. Точность была около 1 мс.

Ответ 9

def start(self):
    sec_arg = 10.0
    cptr = 0
    time_start = time.time()
    time_init = time.time()
    while True:
        cptr += 1
        time_start = time.time()
        time.sleep(((time_init + (sec_arg * cptr)) - time_start ))

        # AND YOUR CODE .......
        t00 = threading.Thread(name='thread_request', target=self.send_request, args=([]))
        t00.start()

Не используйте переменную для передачи аргумента sleep(), вы должны вставить вычисление непосредственно в sleep()

И возвращение моего терминала

1 ───── 17: 20: 16.891 ───────────────────

2 ───── 17: 20: 18.891 ───────────────────

3 ───── 17: 20: 20.891 ───────────────────

4 ───── 17: 20: 22.891 ───────────────────

5 ───── 17: 20: 24.891 ───────────────────

....

689 ─── 17: 43: 12.891 ────────────────────

690 ─── 17: 43: 14.890 ────────────────────

691 ─── 17: 43: 16.891 ────────────────────

692 ─── 17: 43: 18.890 ────────────────────

693 ─── 17: 43: 20.891 ────────────────────

...

727 ─── 17: 44: 28.891 ────────────────────

728 ─── 17: 44: 30.891 ────────────────────

729 ─── 17: 44: 32.891 ────────────────────

730 ─── 17: 44: 34.890 ────────────────────

731 ─── 17: 44: 36.891 ────────────────────