ScheduledExecutorService с переменной задержкой
Вы, кажется, смешиваете три совершенно других, ортогональных вещи:
- статичный по сравнению с динамическим ввод
- декларация по сравнению с неявным ввод
- названный по сравнению с анонимным типы
Те три аспекта абсолютно независимы, у них нет ничего вообще, чтобы сделать друг с другом.
Статичный по сравнению с динамическим ввод относится к [1 115], когда проверка типа происходит: динамический контроль типов происходит в [1 116] время выполнения , статический контроль типов происходит перед временем выполнения .
Декларация по сравнению с неявным ввод относится к тому, являются ли типы декларация в исходном коде или нет: явный ввод означает, что программист должен записать типы в исходный код, неявная типизация означает, что система типов понимает их самостоятельно.
Названный по сравнению с анонимным типы относятся к, ну, в общем, имеют ли типы имена или нет.
dynamic ключевое слово в C# 4.0 означает, что эта переменная, параметр, метод, поле, свойство... независимо от того, что с динамическим контролем типов , т.е. что его тип будет проверен во времени выполнения. Все, что не вводится как динамичное, со статическим контролем типов. Является ли тип статичным или динамичным не, только определяет, когда проверка типа происходит, но и в C# 4.0 это также определяет, когда отправка метода происходит. В C# отправка метода сделана перед временем выполнения, на основе статического типа (за исключением полиморфизма подтипа во время выполнения, конечно), тогда как на объектах с динамическим контролем типов в C# 4.0, отправка метода сделана во времени выполнения, на основе типа выполнения.
var ключевое слово в C# 3.0 означает, что эта локальная переменная будет , неявно ввел , т.е. что вместо программиста, записывающего тип явно, система типов поймет его самостоятельно. Это не имеет никакого отношения к динамическому контролю типов, по крайней мере, в C# 3.0. Переменная будет решительно со статическим контролем типов так же, как если бы Вы записали тип сами. Это - просто удобство: например, почему необходимо было бы записать все имена типов дважды в HashMap<int, string> foo = new HashMap<int, string>();, когда система типов может ясно фигура, которая foo является HashMap<int, string>, так вместо этого Вы пишете var foo = new HashMap<int, string();. Обратите внимание на то, что нет ничего динамического или анонимного об этом. Тип статичен, и он имеет имя: HashMap<int, string>. Конечно, в C# 4.0, если система типов выясняет, что правая сторона присвоения является динамичной, тогда тип переменной на левой стороне будет динамичным.
анонимный тип в C# 3.0 означает, что этот тип не имеет никакого имени. Ну, на самом деле реальный анонимные типы потребовали бы назад несовместимого изменения в Общей системе типов, поэтому что на самом деле происходит позади занавеса, то, что компилятор генерирует очень длинное, очень случайное, уникальное и недопустимое название типа и поставит то имя в том, везде, где анонимный тип появляется. Но с точки зрения программиста, тип не имеет никакого имени. Почему это полезно? Ну, иногда у Вас есть промежуточные результаты, в которых Вы только нуждаетесь кратко и затем выбрасываете снова. Давание таких переходных типов, собственное имя подняло бы их до важного уровня, которого они просто не заслуживают. Но снова, нет ничего динамического об этом.
Так, если тип не имеет никакого имени, как программист может обратиться к нему? Ну, она не может! По крайней мере, не непосредственно. Что программист может делать, быть, описывают тип: это имеет два свойства, один названный "название" типа string, другой названный "идентификатор" типа int. Это - тип, который я хочу, но я не забочусь о том, чем это называют.
Вот то, где части начинают объединяться. В C# необходимо объявить типы локальных переменных путем явной записи названий типов. Но, как можно записать название типа, который не имеет никакого имени? Это - то, где var входит: потому что начиная с C# 3.0, это больше не на самом деле верно: Вы больше не должны записывать имена, можно также сказать компилятору понимать его. Так, в то время как то, что я записал в первом абзаце выше, верно, та неявная типизация и анонимные типы не имеют никакого отношения к другому, это также верно, что анонимные типы были бы довольно бесполезны без неявной типизации.
Примечание, однако, что противоположное не верно: неявная типизация совершенно полезна без анонимных типов. var foo = HashMap<int, string> имеет идеальный смысл и в поле зрения нет никакого анонимного типа.
4 ответа
Я не думаю, что вы можете изменить задержку с фиксированной скоростью. Я думаю, вам нужно использовать schedule () для выполнения однократного выполнения и запланировать еще раз после его завершения (с измененным тайм-аутом, если требуется).
Разве вам не следует использовать scheduleAtFixedRate , если вы пытаетесь обработать несколько задач очереди с определенным интервалом? scheduleWithFixedDelay будет ждать только заданную задержку и затем выполнит одну задачу из очереди.
В любом случае методы schedule * в ScheduledExecutorService будут вернуть ссылку ScheduledFuture . Если вы хотите изменить скорость, вы можете отменить ScheduledFuture и перенести задачу с другой скоростью.
Используйте расписание (Callable вместо scheduleAtFixedRate или scheduleWithFixedDelay . Затем убедитесь, что ваш Callable перепланировал себя или новый экземпляр Callable в какой-то момент в будущем. Например:
// Create Callable instance to schedule.
Callable<Void> c = new Callable<Void>() {
public Void call() {
try {
// Do work.
} finally {
// Reschedule in new Callable, typically with a delay based on the result
// of this Callable. In this example the Callable is stateless so we
// simply reschedule passing a reference to this.
service.schedule(this, 5000L, TimeUnit.MILLISECONDS);
}
return null;
}
}
service.schedule(c);
Этот подход позволяет избежать необходимости выключения и воссоздания ScheduledExecutorService .
scheduleWithFixedDelay (...) возвращает RunnableScheduledFuture. Чтобы перенести его, вы можете просто отменить и перенести его. Чтобы перенести его, вы можете просто обернуть RunnableScheduledFuture новым Runnable:
new Runnable() {
public void run() {
((RunnableScheduledFuture)future).run();
}
};