как выполнить петлю n времена за 1 секунду

Вы никогда не можете быть уверены, что это произойдет точно N времена в секунду, но это идет как это:

long taskTime = 0;
long sleepTime = 1000/N;
while (true) {
  taskTime = System.currentTimeMillis();
  //do something
  taskTime = System.currentTimeMillis()-taskTime;
  if (sleepTime-taskTime > 0 ) {
    Thread.sleep(sleepTime-taskTime);
  }
}

Я щелкнул бы проблемой: не ограничивайте петлю временами N за секунду. Вместо этого процесс N единицы работы равномерно распределяется за желаемое время.

Таким образом, вычислите, сколько времени прошло начиная с начало (или предыдущая работа ), интерполируйте это в , производительность и делает так много работы (фактор во время начала/в предыдущий раз и объем работы, который был сделан). Это - фундаментальное подкрепление многих двигателей игры/анимации - a "время дельты".

Тогда звоните урожай в конце каждой петли, чтобы "быть хорошим" - или скорее предотвратить еду 99% + использование центрального процессора! У самого урожая есть минимальное разрешение <глоток> 1 , но эффекты обычно соответствуют, особенно интерполируя соответственно.

Поскольку подход интерполяции используется, это должно работать на весь N (что может пробег в выделенное время), даже если это означает делать еще много N каждая петля. Также возможно, что никакая работа не могла бы быть сделана никакая конкретная петля для маленького N, но , урожай делает этот вид "дополнительного занятого перекручивания" дешевым с точки зрения загрузки ЦП <глоток> 2 .

Вот некоторый псевдокод, чтобы распечатать 20 "x" s за секунду, куда теперь возвращает доли секунды:

rate = 20      //per second - "N times per second"
done = 0
goal = 1 * rate//same as rate for 1 second
start = now()
while done < goal:
    target = floor((now() - start) * rate)
    work = (target - done)//work might be 0, that's okay
    for 0 upto work:
         print("x")
    done += work
    yield()

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

¹ The time resolution of an actual sleep/yield is implementation-dependent and varies by by system. For instance, it might range from as low as 1ms on Linux to 10-15ms on windows.

² In addition to dealing with a time delta, the sleep period can be altered, as per Dariusz Wawer's answer. However, this adds complexity and a simple yield is often sufficient.

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

long startTime = System.currentTimeMillis();
long msPerIteration = 1000000/iterationsPerSecond;
long i=0;
while (true) {
   //do stuff

    long msWaiting = startTime + (msPerIteration * ++i) - System.currentTimeMillis();

    if (msWaiting > 0)
        Thread.sleep(msWaiting);
}

Измените петлю, чтобы в то время как (верный) .

Проверьте время в миллисекунды перед вашим в то время как петля. В конце , в то время как петля получают время в миллисекундах и видят, прошли ли 1000 из них. Раз так разрыв .

Псевдо код:

Create Timer t;
t.Start;
int counter = N;
While ((t.Elapsedtime < 1 Second) AND (N > 0))
{
    call your_function();
    N--;
}

your_function()
{
    printf(".........");
    int x=0;
    printf("The value of x is ");
}

long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start <= 1000) {
 //Your code goes here
}

Все это заботится, - то, что ваш код будет закреплен петлей для 1000 миллисекунд. Число раз это сделано, сомнительно и может измениться на каждом пробеге.