Início / coding / Perguntas / 79597115
Accepted
Isaac Honeyman
Asked: 2025-04-29 02:44:23 +0800 CST

C# Menos intensivo em recursos/processador para bloquear threads com precisão em curtos períodos de tempo

  • 772

Estou desenvolvendo uma aplicação de console que executa periodicamente duas threads: uma para uma função tickEvent e outra para atualizar a tela do console. Atualmente, cada thread simplesmente bloqueia em uma verificação de condição até que seja hora do próximo ciclo.

Essa abordagem funciona, mas exige muito do processador e, para um aplicativo que executo em segundo plano, resulta em muito ruído dos meus ventiladores para ser prático.

Abordagem atual:

static void HandleTickBehaviour()
{
    Stopwatch tickDuration = new(); //time tick starts

    while (true)
    {
        tickDuration.Restart();

        Tick.Invoke(ElapsedTicks); // invoke all tick event watchers
        Profiler.CalcTime.Add(tickDuration.ElapsedMilliseconds); // how long it took for all tick event to run

        long targetThreadDelay = (int)(Math.Max(25 - Math.Max(_deltaTime - 25, 0), 0) / 1000d * Stopwatch.Frequency); // how long to wait for next tick (25ms - delta time)
        while (true) if (tickDuration.ElapsedTicks >= targetThreadDelay) break;

        _deltaTime = tickDuration.ElapsedMilliseconds;
        Profiler.TickTime.Add(_deltaTime);
        ElapsedTicks++;
    }
}

internal static void HandleConsoleRender()
{
    Stopwatch frameDuration = new();

    while (true)
    {
        frameDuration.Restart();
        RenderConsole();

        while (true) if (frameDuration.ElapsedTicks >= displayWindowsTickInterval) break;

        Profiler.RenderTime.Add(frameDuration.ElapsedTicks);
    }
}

Resultados do bloqueio de threads : Resultados

A outra abordagem que tentei implementar é usar thread.sleep(), no entanto, como essas funções são chamadas a cada dois ms, o atraso para reativar o thread é simplesmente muito grande, e mesmo tentar levar isso em conta faz com que as atualizações aconteçam de forma imprevisível.

Resultados de Thread.Sleep(): Resultados

c#

2 respostas

  1. Best Answer

    Para fazer algo periodicamente, a solução geral é usar um timer. Existem vários timers para escolher, mas todos têm uma resolução padrão de 15,6 ms. Isso também inclui Thread.Sleep, pois usa o mesmo mecanismo subjacente. Os números observados estão bem próximos do dobro disso e são mais ou menos o que eu esperaria. Isso não significa que Thread.Sleep tenha uma sobrecarga de 5 ms, apenas significa que os tempos serão quantizados em múltiplos de 15,6 ms.

    A menos que você esteja fazendo algo muito sensível à latência (como áudio/vídeo), essa resolução normalmente é suficiente, e a solução mais simples é usar um timer normal, como um timer periódico , manter a taxa de tique padrão do Windows e corrigir quaisquer problemas de "imprevisibilidade" que você esteja tendo.

    Existem maneiras de obter temporizadores de alta resolução. O hardware deve ser capaz de suportar pelo menos 100us de resolução, mas, até onde sei, isso ainda não está exposto na API .NET, então você precisará usar P/Invoke para chamar as APIs nativas do Windows. Consulte Temporizadores de alta resolução . Existem também "Temporizadores multimídia" que parecem usar uma API um pouco mais antiga para fazer essencialmente a mesma coisa. Infelizmente, não estou familiarizado o suficiente com isso para fornecer uma implementação completa, mas pode haver bibliotecas disponíveis. O HighPrecisionTimer foi sugerido pelo Google, mas não tenho experiência pessoal com ele.

    Eu também consideraria a forma como suas threads se comunicam. Atualmente, não há sincronização, e presumo que o comportamento pretendido seja que o loop de renderização seja executado uma vez para cada execução do outro loop. Para isso, você pode, por exemplo, usar um BlockingCollection ou um evento de redefinição manual . Existem também bibliotecas de pipelining, como DataFlow ou Channels, que podem ser úteis para o que você estiver tentando fazer.

    • 2

  2. Este é um exemplo clássico de asyncprogramação. Especificamente, você quer usar um PeriodicTimere aguardar cada tique (portanto, sem usar CPU). Algo como:

    internal static async Task HandleConsoleRender()
{
    PeriodicTimer frameTimer = new(TimeSpan.FromTicks(displayWindowsTickInterval));

    while (true)
    {
        RenderConsole();

        // avoid context switches unless absolutely necessary
        await frameTimer.WaitForNextTickAsync().ConfigureAwait(false);

        // if you still need this, use a Stopwatch like you were before
        //Profiler.RenderTime.Add(frameDuration.ElapsedTicks);
    }
}
    • 1

relate perguntas