Является ли wait (1) в неблокирующем цикле while (true) более эффективным, чем использование wait () и notify ()?

Что касается исходного вопроса о том, почему while (true); занимает больше ЦП, чем while (true) { wait(1); }, подумайте: современный ЦП может выполнять миллиарды инструкций в секунду. При использовании цикла wait(1), если он идеален и каждый раз ожидает ровно одну миллисекунду, вы ограничиваете процессор до одной тысячи инструкций в секунду. Без него нет ограничений, и вместо этого он может выполнять замкнутый цикл миллиарды раз в секунду.

Что касается нового вопроса о том, что более эффективно, подход while (true) { wait(1); } против wait() и notify() рассмотрения ...

Допустим, вы ждете по условию. Вариант первый:

while (true) {
    wait(1);
    if (condition()) {
        break;
    }
}

vs.

wait();

и в другом месте:

//code which causes condition() to be true
notify();

Скажем, требуется 10 секунд, чтобы условие стало истинным. В первом подходе вы звоните wait(1) 10 000 раз и проверяете condition() 10 000 раз. Во втором подходе вы вызываете wait() один раз и notify() один раз.

Это вопрос с подвохом?

Когда вы помещаете «wait ()» в цикл, он освобождает переменную синхронизации, позволяя другому потоку двигаться вперед и в конечном итоге уведомлять этот поток о том, что он может продолжить. Поток не будет продолжен и не будет использовать циклы процессора, пока не получит это уведомление. И поэтому wait / notify необходимо вызывать из блоков или методов sync'd (не ясно, делаете ли вы это здесь).

Напротив, «while ... true» - это бесконечный цикл, который будет использовать каждый цикл процессора, который вы ему даете, до тех пор, пока не будет выполнено конечное условие.

Я рекомендую хорошую книгу по потокам Java и синхронизации, например https://rads.stackoverflow.com/amzn/click/com/0130170070

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

Это станет особенно важным, если у вас работает много этих потоков, поскольку накладные расходы приходятся на поток.

По сути, Клаудиу прав: процессоры действительно очень быстрые.

Но есть еще один фактор, который следует учитывать: на самом деле wait(1) всегда необходим в неблокирующих потоках, чтобы позволить другим потокам продолжить работу. Потому что, если ожидания вообще нет, ОС не может выделить ресурсы какому-либо другому потоку, и они будут голодать. С другой стороны, wait(1) может в действительности вызвать гораздо более длительное ожидание в зависимости от того, как ОС распределяет ресурсы. Но это зависит от ОС.

При программировании всегда нужно учитывать 2 фактора:

1. объем кеш-памяти / ОЗУ и

2. время, необходимое для потока / процесса.

Следовательно, все зависит от количества ресурсов, используемых ЗА ВРЕМЯ: МБ / с (или в целом: байтов / с). Вы не можете принимать правильные решения только на основе выделенных ресурсов, как намереваются делать многие программисты. Возможно даже, что вышеуказанный неблокирующий floop использует намного меньше ресурсов, чем блокирующий, потому что нет накладных расходов на синхронизацию. Так что никогда не забывайте о временном измерении.

Заключение. Более быстрые неблокирующие программы (могут) использовать меньше ресурсов.