Точность задачи.Delay

Question

Я разрабатываю Windows 10 Universal App в C#/Xaml, я использую await Task.Delay (delayInMilliseconds), чтобы приостановить метод для заданного времени. Мой сценарий несколько в реальном времени, поэтому он очень чувствителен к изменениям времени, и мне нужно убедиться, что, когда я приостановил метод, скажем, 8 миллисекунд, он будет приостановлен на 8 миллисекунд. Я заметил, что фактический временной интервал, для которого ** Task.Delay ** приостанавливает метод, отличается от того, что передается как параметр задержки, в течение 1 до 30 мс, причем длина «отклонения» различна для каждого вызова. Итак, когда я хочу спать в течение 8 миллисекунд, моя система спит от 9 до 39 миллисекунд, и это полностью разрушает мой сценарий. Итак, мой вопрос: какой лучший способ заменить ** Task.Delay ** и добиться хорошей точности? В настоящее время я использую этот метод:

public static void Delay1(int delay) 
    { 
     long mt = delay * TimeSpan.TicksPerMillisecond; 
     Stopwatch s = Stopwatch.StarNew(); 
     while (true) 
     { 
      if (s.Elapsed.TotalMilliseconds > delay) 
      { 
       return; 
      } 
     } 
    } 

но guees он потребляет много ресурсов, то есть 100% от сердечника процессора. Если у пользователя небольшое количество ядер процессора, это будет очень мало.

Answer 1

По msdn это не возможно достичь большей точности в связи с разрешением часов системы:

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

Answer 2

Вы должны использовать таймеры мультимедиа. Они очень точны. Посмотрите здесь: https://social.msdn.microsoft.com/Forums/vstudio/en-US/2024e360-d45f-42a1-b818-da40f7d4264c/accurate-timer

Answer 3

Кажется, я нашел sattisfactory решения:

нового System.Threading.ManualResetEvent (ложный) .WaitOne (delayInMilliseconds) вместо ждет Task.Delay (delayInMilliseconds);

Я использовал следующий код, чтобы проверить оба метода:

async void Probe() 
    { 
     for (int i = 0; i < 1000; i++) 
     { 
      // METHOD 1 
      await Task.Delay(3); 
      // METHOD 2 
      new System.Threading.ManualResetEvent(false).WaitOne(3); 
     } 
    } 

Код выше должен занять ровно 3 секунды, чтобы выполнить. С МЕТОДОМ 2 это заняло около 3300 мс, так что eror составляет 0,3 мс за звонок. Приемлемо для меня. Но МЕТОД 1 tok около 15 секунд (!) Для выполнения, что дает совершенно неприемлемую ошибку для моего сценария. Я только задаюсь вопросом, что такое использование процессора с помощью метода 2, надеюсь, что он не использует опрос, документация говорит что-то об использовании сигналов, но, к сожалению, это автоматически не означает, что опрос не используется в другом месте.

Answer 4

После трудолюбия я нашел решение для спящего потока в течение определенного времени, а ошибка - всего от 3 до 4 микросекунд на моем процессоре Core 2 Duo 3,00 ГГц. Вот он:

Вот код. (Код C# также указан в конце.) Используйте "ThreadSleepHandler":

Public Class ThreadSleepHandler 
Private Stopwatch As New Stopwatch 
Private SpinStopwatch As New Stopwatch 
Private Average As New TimeSpan 
Private Spinner As Threading.SpinWait 
Public Sub Sleep(Time As TimeSpan) 
    Stopwatch.Restart() 
    If Average.Ticks = 0 Then Average = GetSpinTime() 
    While Stopwatch.Elapsed < Time 
     If Stopwatch.Elapsed + Average < Time Then 
      Average = TimeSpan.FromTicks((Average + GetSpinTime()).Ticks/2) 
     End If 
    End While 
End Sub 
Public Function GetSpinTime() As TimeSpan 
    SpinStopwatch.Restart() 
    Spinner.SpinOnce() 
    SpinStopwatch.Stop() 
    Return SpinStopwatch.Elapsed 
End Function 
End Class 

Вот пример кода:

Sub Main() 
    Dim handler As New ThreadSleepHandler 
    Dim stopwatch As New Stopwatch 
    Do 
     stopwatch.Restart() 
     handler.Sleep(TimeSpan.FromSeconds(1)) 
     stopwatch.Stop() 
     Console.WriteLine(stopwatch.Elapsed) 
    Loop 
End Sub 

Для C# программистов здесь есть код (Я преобразовал этот код, но я не уверен):

static class Main 
{ 
public static void Main() 
{ 
    ThreadSleepHandler handler = new ThreadSleepHandler(); 
    Stopwatch stopwatch = new Stopwatch(); 
    do { 
     stopwatch.Restart(); 
     handler.Sleep(TimeSpan.FromSeconds(1)); 
     stopwatch.Stop(); 
     Console.WriteLine(stopwatch.Elapsed); 
    } while (true); 
} 
} 
public class ThreadSleepHandler 
{ 
private Stopwatch Stopwatch = new Stopwatch(); 
private Stopwatch SpinStopwatch = new Stopwatch(); 
private TimeSpan Average = new TimeSpan(); 
private Threading.SpinWait Spinner; 
public void Sleep(TimeSpan Time) 
{ 
    Stopwatch.Restart(); 
    if (Average.Ticks == 0) 
     Average = GetSpinTime(); 
    while (Stopwatch.Elapsed < Time) { 
     if (Stopwatch.Elapsed + Average < Time) { 
      Average = TimeSpan.FromTicks((Average + GetSpinTime()).Ticks/2); 
     } 
    } 
} 
public TimeSpan GetSpinTime() 
{ 
    SpinStopwatch.Restart(); 
    Spinner.SpinOnce(); 
    SpinStopwatch.Stop(); 
    return SpinStopwatch.Elapsed; 
} 
} 

Примечание: «ThreadSleepHandler» является небезопасным. Вы не можете использовать один «ThreadSleepHandler» для нескольких потоков.

Первое время сна будет недостаточно точным.

Answer 5

В моих тестах я обнаружил, что DispatcherTimer с интервалом 20 мс будет обеспечивать достаточно плавную анимацию, если вы должны сделать это в коде. Выполнение этого в XAML - еще одна альтернатива, как уже упоминалось.