Leistungsschaden zwischen Aufgabenansatz und dem Ansatz des Schleifens im Umgang mit Timeout ⇐ C#

[Anonymous]

Heute war mein Chef mich gefragt, was die Leistung zwischen diesen beiden Ansätzen mehr schädigen wird: < /p>
var delayTask = Task.Delay(timeout);
var doSomethingTask = Task.Run( async ()=> { //do something here });
await Task.WhenAny(delayTask, doSomethingTask)
< /code>
und < /p>
while (GetDifferenceBetweenTimestamp(timestart, now) > timeout) { //do something here }
< /code>
Meine Antwort war, dass der Aufgabenansatz besser sein wird, aber er sagte, dass es doppelt so gut wie bei CPU arbeiten wird. < /p>
Ich habe großen Zweifel an dieser Antwort Also frage ich Chatgpt einen Testcode wie diesen: < /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>
Das Ergebnis zeigt, dass der Aufgabenansatz besser ist, aber ich frage mich, ob es wahr ist. Was ist der richtige Weg, wenn man mit solcher Zeitüberschreitungen zu tun hat? Die schwere Arbeit muss gestoppt werden. Also antwortete ich ihm mit 2 Ansätzen: Wickeln Sie die schwere Arbeit mit einer Aufgabe ein und führen Sie eine neue Aufgabenverzögerung bis zum Zeitüberschreitungen durch und warten Sie auf beide Aufgaben, oder weil die schwere Aufgabe nur die Überprüfung des Kontextes wiederholt, um zu wissen, was als nächstes zu tun ist. Also sage ich ihm, dass wir uns vor der Schleife einige Zeit nehmen könnten, und überprüfen, ob die Unterschiede zwischen jetzt und der Zeit größer als die Auszeit beginnen, wenn sie dann die Schleife stoppt. Dann fragte er mich, ob sich die 2 Aufgaben nähern würden, die Dinge verlangsamen würden oder nicht. Also fragte ich Chatgpt um die Antwort und bekam den Testcode. Jetzt weiß ich, dass ich es falsch überprüfe und hoffe, ich könnte wissen, wie ich wissen soll, was ich in diesem Fall tun soll.