Выполнить код на х секунд в Java?

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

Если вы хотите, чтобы поток что-то сделал, но хотите, чтобы он остановился через некоторое время, используйте что-то вроде:

class Foo implements Runnable {
    private volatile boolean killed = false;

    public void run() {
        while (!killed) {
            try { doOnce(); } catch (InterruptedException ex) { killed = true; }
        }
    }

    public void kill() { killed = true; }
    private void doOnce() throws InterruptedException { /* .. */ }
}

, а из основного потока выполните:

Foo foo = new Foo(); 
Thread thread = new Thread(foo);
thread.start();

/* when you want to stop it */
foo.kill();
thread.interrupt();

попробуйте это:

public class SleepMessages {
    public static void main(String args[]) throws InterruptedException {
        String importantInfo[] = {
            "Mares eat oats",
            "Does eat oats",
            "Little lambs eat ivy",
            "A kid will eat ivy too"
        };

        for (int i = 0; i < importantInfo.length; i++) {
            //Pause for 15 seconds
            Thread.sleep(15000);
            //Print a message
            System.out.println(importantInfo[i]);
        }
    }
}

подробнее: здесь

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

Альтернативой является запуск таймера / потока, который устанавливает флаг по истечении 15 секунд. Этот флаг должен быть помечен как изменчивый, иначе ваш цикл может не увидеть изменения значения.

Если вы заботитесь об эффективности, что будет дороже: получение системного времени один раз за цикл или доступ к изменчивой переменной? Я не знаю, какой из них более эффективен - вы можете протестировать его, если это действительно важно.

Для простого, поддерживаемого кода я бы выбрал метод проверки таймера:

long endTime = System.currentTimeMillis() + 15000
while (System.currentTimeMillis() < endTime) {
  //loop
} 

Вам может быть интересно запланировать TimerTask, который останавливает другой поток или изменяет состояние вашего цикла.

Решение, аналогичное @Tom Hawtin без размера произвольного цикла.

final long end = System.nanoTime() + 15 * 1000 * 1000 * 1000L;
int loop = 1;
do {
    for (int i=0; i<loop; ++i) {
        ...
    }
    loop++;
} while (System.nanoTime() < end);

В этом случае размер внутреннего цикла начинается с малого, но увеличивается, если цикл выполняется особенно быстро. Если он достаточно медленный, то итерация может произойти только один раз.

Предполагая, что вы хотите, чтобы цикл сделать что-то разумное, вы можете найти его быстрее, чтобы проверить летучий флаг. Подождите еще 15 секунд (или используйте таймер), а затем установите его.

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

final long start = System.nanoTime();
do {
    for (int i=0; i<200, ++i) {
        ...
    }
} while (System.nanoTime()-start < 15L*1000L*1000L*1000L);

System.NANOTIME не путают системные изменения. Использование длинных буквальных чисел важно.

IDIOM C # заключается в том, что если объект реализует IDSPosable , вы используете с использованием блока . Это позволит всем ресурсам, используемым объектом, быть утилизированным должным образом. Вы не должны знать детали реализации MemoryStream . То, что вы знаете, состоит в том, что он реализует IDSposable , поэтому вы должны правильно распознаваться. Далее, вы думаете, что вы знаете, что это не нужно, чтобы освободить какие-либо ресурсы, но как вы знаете, что в будущем MemoryStream не изменит свою базовую реализацию, чтобы он использовал ресурсы, которые необходимо Быть освобожденным с использованием Dispose ? Вы этого не сделаете, так как он реализует IDissoable У вас есть больше будущего кода, просто используя шаблон. Во-вторых, что, если вы измените свой код в будущем, чтобы использовать другой тип поток , который имеет управляемые ресурсы? Оборачивая MemoryStream в , используя блок , теперь вы сокращаете проблемы технического обслуживания в будущем; Опять же, это правильный способ использовать объекты и, в частности, поток , который реализуется IDSposable . В-третьих, это четкий способ сигнала для читателей, которые вы делаете с использованием объекта; Это то, что читатели вашего кода ожидают увидеть, когда они увидят, что вы используете объекты, которые реализуют IDSPosable . Наконец, это текущая реализация MemoryStream.dispose :

protected override void Dispose(bool disposing) {
    try {
        if (disposing) {
            this._isOpen = false;
            this._writable = false;
            this._expandable = false;
        }
     }
     finally {
         base.Dispose(disposing);
     }
}

Итак, это отмечает поток как закрытый, не пишетный и не вырастешный. Если каким-то образом кто-то еще получил ссылку на одно и то же MemoryStream , теперь он становится непригодным для них, что может быть хорошей вещью. Но это действительно наименее важный вопрос; Детали реализации не имеют значения.

Используйте с использованием блока , потому что MemoryStream Allurage IDissoable . Не используйте , используя блок , потому что вы думаете, что MemoryStream не имеет никаких ресурсов, которые необходимо освободить.

Никогда не проверяйте текущее время в тесной петле.

В противном случае кто-то с ноутбуком может получить его / ее круг сожжены перегретой процессором. Я слышал истории этого на самом деле происходящим.

Для подхода java.util.concurrent обратитесь к Глава 6 5-й АНВА на практике (раздел 6.3.7 Размещение временных ограничений на заданиях, стр. 131).

Пример кода: Получение рекламы с бюджетом времени.