Повреждение производительности между подходом задачи и подходом к петле при работе с тайм-аутом ⇐ C#

[Anonymous]

Сегодня мой босс спросил меня, что будет больше повредить производительность между этими двумя подходами: < /p>
var delayTask = Task.Delay(timeout);
var doSomethingTask = Task.Run( async ()=> { //do something here });
await Task.WhenAny(delayTask, doSomethingTask)
< /code>
и < /p>
while (GetDifferenceBetweenTimestamp(timestart, now) > timeout) { //do something here }
< /code>
Мой ответ был, что подход задания будет лучше, но он сказал, что он будет дважды работать над процессором. Поэтому я спрашиваю CHATGPT тестового кода, как это: < /p>
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

class PerformanceTest
{
static async Task TaskBasedMethod(int timeout, int instances)
{
var stopwatch = Stopwatch.StartNew();

Task[] tasks = new Task[instances];

for (int i = 0; i < instances; i++)
{
tasks = Task.Run(async () =>
{
var delayTask = Task.Delay(timeout);
var doSomethingTask = Task.Run(() =>
{
int count = 0;
while (count < 1000000) count++; // Simulating work
});

await Task.WhenAny(delayTask, doSomethingTask);
});
}

await Task.WhenAll(tasks);
stopwatch.Stop();

Console.WriteLine($"Task-Based Method - Total Time: {stopwatch.ElapsedMilliseconds} ms");
}

static void LoopBasedMethod(int timeout, int instances)
{
var stopwatch = Stopwatch.StartNew();

Thread[] threads = new Thread[instances];

for (int i = 0; i < instances; i++)
{
threads = new Thread(() =>
{
var startTime = DateTime.UtcNow;
int count = 0;
while ((DateTime.UtcNow - startTime).TotalMilliseconds < timeout)
{
count++; // Simulating work
}
});

threads.Start();
}

foreach (var thread in threads)
{
thread.Join(); // Wait for all to finish
}

stopwatch.Stop();
Console.WriteLine($"Loop-Based Method - Total Time: {stopwatch.ElapsedMilliseconds} ms");
}

static void MeasureResourceUsage()
{
var process = Process.GetCurrentProcess();

Console.WriteLine($"CPU Time: {process.TotalProcessorTime.TotalMilliseconds} ms");
Console.WriteLine($"Memory Usage: {process.WorkingSet64 / 1024 / 1024} MB");
}

static async Task Main()
{
int timeout = 100; // 100ms
int instances = 500; // 1M instances

Console.WriteLine("Testing Task-Based Method...");
await TaskBasedMethod(timeout, instances);
MeasureResourceUsage();

Console.WriteLine("Testing Loop-Based Method...");
LoopBasedMethod(timeout, instances);
MeasureResourceUsage();
}
}

< /code>
Результат показывает, что подход задачи лучше, но мне интересно, правда ли это. Итак, как правильный путь, когда работаете с такими таймами? Тяжелая работа должна быть остановлена. Поэтому я ответил ему с двумя подходами: оберните тяжелую работу одной задачей и сделайте новую задержку задачи до тайм -аута и ждать обеих задач, или потому что тяжелая задача просто повторяет контекст, чтобы знать, что делать дальше, затем повторите, Поэтому я говорю ему, что мы могли бы потратить время на начало до петли и проверить, начинаются ли различия между сейчас и временем больше, чем время, если он остановит петлю. Затем он спросил меня, подходит ли 2 задачи, замедлит ситуацию или нет. Поэтому я попросил Chatgpt ответить и получил тестовый код. Теперь я знаю, что проверяю это неправильно, и я надеюсь, что могу знать, как мне знать, что мне делать в этом случае.

Подробнее здесь: https://stackoverflow.com/questions/794 ... dealing-wi