Точный сон для Java в Windows

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

Итак, хотя я не знаю, чего вы пытаетесь достичь, я совершенно уверен, что вы должны использовать вместо этого таймер.

JDK предлагает класс Timer.

http://java.sun.com/j2se/1.5.0/docs/api/java/util/Timer.html

Чтение документов ясно указывает на то, что помимо сантехники, чтобы сделать эту обобщенную структуру, она не использует ничего более сложного, чем вызов Object.wait (время ожидания):

http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Object.html#wait (long)

Таким образом, вы, вероятно, можете прекратить погоню, просто воспользовавшись Object #, подождите сами.

Помимо этих соображений, остается факт, что JVM не может гарантировать точность времени на разных платформах. (Прочитайте документы на http://java.sun.com/j2se/1.5.0/docs/api/java/lang/System.html#currentTimeMillis () )

Я думаю, что вы ' Вам нужно будет поэкспериментировать с компромиссным решением, сочетающим таймер и опрос занятости, если вы хотите добиться максимальной точности синхронизации на вашей платформе. Фактически Object # wait (1) -> System # nanoTime -> Calculate Delta -> [loop, если необходимо].

Если вы хотите развернуть свой собственный, JNI в значительной степени оставляет его открытым для решений, специфичных для платформы. Я блаженно не осведомлен о внутренностях Windows, но, очевидно, если хост-операционная система действительно обеспечивает достаточно точные службы таймера в реальном времени, базовая структура установки собственной библиотеки timerRequest (timedelta, callback) не должна быть недосягаемой.

Использовать одно из переопределений Thread :: join в текущем потоке. Вы указываете количество миллисекунд (и наносекунд) ожидания.

Вы можете попробовать использовать новые библиотеки параллелизма. Примерно так:

private static final BlockingQueue SLEEPER = new ArrayBlockingQueue(1);
public static void main(String... args) throws InterruptedException {
    for(int i=0;i<100;i++) {
        long start = System.nanoTime();
        SLEEPER.poll(2, TimeUnit.MILLISECONDS);
        long time = System.nanoTime() - start;
        System.out.printf("Sleep %5.1f%n", time/1e6);
    }
}

Это спит от 2,6 до 2,8 миллисекунд.

Похоже, вам нужна реализация реального времени Java .

The Long.MAX_VALUE hack is the working solution.

I tried Object.wait(int milis) to replace Thread.sleep, but found that Object.wait is as accurate as Thread.sleep (10ms under Windows). Without the hack, both methods are not suitable for any animation

Это задержка на ~ 5 месяцев, но может быть полезно для людей, читающих этот вопрос. Я обнаружил, что java.util.concurrent.locks.LockSupport.parkNanos () делает то же самое, что и Thread.sleep () , но с наносекундной точностью (теоретически) и гораздо большей точностью. чем Thread.sleep () на практике. Это, конечно, зависит от среды выполнения Java, которую вы используете, поэтому YMMV.

Посмотрите: LockSupport.parkNanos

(я проверил это на виртуальной машине Sun 1.6.0_16-b01 для Linux)

К сожалению, начиная с Java 6 все методы java, связанные со сном, в Windows OS [включая LockSupport.awaitNanos()] основаны на миллисекундах, как уже упоминалось несколькими людьми выше.

Одним из способов подсчета точного интервала является "спин-ядро". Метод System.nanoTime() дает вам достаточно точный счетчик относительного времени. Стоимость этого вызова зависит от вашего аппаратного обеспечения и лежит где-то в районе 2000-50 нано.

Вот предложенная альтернатива Thread.sleep():

   public static void sleepNanos (long nanoDuration) throws InterruptedException {
        final long end = System.nanoTime() + nanoDuration;
        long timeLeft = nanoDuration;
        do {
            if (timeLeft > SLEEP_PRECISION)
                Thread.sleep (1);
            else
                if (timeLeft > SPIN_YIELD_PRECISION)
                    Thread.yield();

            timeLeft = end - System.nanoTime();
        } while (timeLeft > 0);
    }

У этого подхода есть один недостаток - в последние 2-3 миллисекунды ожидания происходит удар по ядру процессора. Обратите внимание, что sleep()/yield() будет делиться с другими потоками/процессами. Если вы готовы пожертвовать немного CPU, это даст вам очень точный sleep.