Thread.Sleep() in C#

1. Warum thread.sleep() in C# schädlich ist
2. Funktionsweise von thread.sleep() in C#
3. Asynchrone Programmierung
4. Zwei Methoden gleichzeitig ausführen (Schlüsselwörter async und await in C#)

In dieser Anleitung erfahren wir, warum die Verwendung von thread.sleep() in C# als schädlich angesehen wird und warum dieser spezielle Ansatz nicht verwendet werden sollte.

Was passiert bei Verwendung von thread.sleep()? Gibt es einen alternativen Ansatz?

Erfahre alles in diesem Ratgeber. Tauchen wir ein.

Warum thread.sleep() in C# schädlich ist

Um zu verstehen, warum thread.sleep() schädlich ist, müssen wir die Arbeit hinter dieser Methode verstehen. Nun, in C# hat die sleep-Methode ihren Nutzen.

Sie können es verwenden, um die aktuelle Funktionalität (Thread-Ausführung) für einen bestimmten Zeitraum anzuhalten oder auszusetzen. Wir können die Zeit in Millisekunden übergeben, um die Ausführung des Threads für einige Zeit auszusetzen.

Wir können auch die Eigenschaft TimeSpan verwenden, wie im folgenden Code gezeigt.

// Time in milliseconds
Thread.Sleep(5000);
Or
    // Time in hours, minutes, seconds
    TimeSpan tsObj = new TimeSpan(0, 0, 5);
Thread.Sleep(tsObj);

Jetzt stoppen beide der oben genannten Ansätze das Programm für fünf Sekunden. Das bedeutet, dass wir durch den obigen Code versuchen, den Thread für 1 Sekunde zu unterbrechen.

Aber was hat das alles zu bedeuten? Lassen Sie uns die Funktionsweise verstehen.

Funktionsweise von thread.sleep() in C#

Wir alle wissen, dass ein Programm zeilenweise abläuft, dh das gesamte Programm läuft synchron, Zeile für Zeile. Manchmal müssen wir während der Programmierung eine Aufgabe ausführen, die einige Zeit in Anspruch nimmt.

Wenn wir beispielsweise die Daten von einer API abrufen, können wir die Funktion sleep verwenden, um sie warten zu lassen, diese Daten von der API abzurufen und den Rest des Programms später auszuführen. Dies ist notwendig, aber ein sehr schädlicher und schlechter Ansatz.

Beispielsweise könnten die Daten, die wir abzurufen versuchen, umfangreich sein und Zeit in Anspruch nehmen. Unser Programm wird während dieser Zeit eingestellt; das ist kein idealer Ansatz.

Thread.Sleep(n) bedeutet, dass der laufende Thread in n Millisekunden für so viele Zeitscheiben (auch als Threadquanten bezeichnet) wie möglich angehalten wird. Die Dauer einer Zeitscheibe variiert je nach Windows-Version/-Typ und verwendetem Prozessor, beträgt aber typischerweise zwischen 15 und 30 Millisekunden.

Dies weist darauf hin, dass der Thread wahrscheinlich länger als n Millisekunden blockiert. Es ist unwahrscheinlich, dass Ihr Thread genau n Millisekunden später wieder aufwacht.

Somit dient Thread.Sleep dem Timing nicht.

Threads sind eine endliche Ressource, die ungefähr 200.000 Zyklen für die Erstellung und 100.000 Zyklen für die Zerstörung benötigt. Standardmäßig verwenden sie 2.000 bis 8.000 Zyklen für jeden Kontextübergang und reservieren 1 Megabyte virtuellen Speicher für ihren Stack.

Was ist der alternative Ansatz

Manchmal müssen wir unseren Thread verzögern, damit das Programm perfekt läuft. Wie oben erwähnt, müssen wir möglicherweise einige API-Daten abrufen, was einige Zeit in Anspruch nimmt.

Aber deswegen das ganze Programm zu stoppen, ist ein schlechter Ansatz. Also, wie vermeiden wir das?

Lassen Sie uns Ihnen die asynchrone Programmierung vorstellen.

Asynchrone Programmierung

Die Schlüsselwörter async und await in C# tragen dazu bei, dass asynchrone Programmierung heutzutage weit verbreitet ist. Die gesamte Anwendung muss warten, bis der Vorgang abgeschlossen ist, wenn Sie mit der Benutzeroberfläche arbeiten und eine lang andauernde Methode verwenden, die viel Zeit in Anspruch nimmt, z. B. das Lesen einer großen Datei oder das Klicken auf eine Schaltfläche.

Mit anderen Worten, wenn ein Prozess in einer synchronen Anwendung blockiert wird, wird auch die gesamte Anwendung angehalten, und unsere Anwendung funktioniert nicht mehr, bis die gesamte Aufgabe abgeschlossen ist.

In dieser Situation ist die asynchrone Programmierung sehr nützlich. Die Anwendung kann mit Aufgaben fortfahren, die nicht von der Erledigung abhängen, indem asynchrone Programmierung verwendet wird.

Mit Hilfe der Schlüsselwörter async und await erreichen wir mit viel weniger Aufwand alle Vorteile der herkömmlichen asynchronen Programmierung.

Zwei Methoden gleichzeitig ausführen (Schlüsselwörter async und await in C#)

Nehmen wir an, wir haben zwei Methoden, FirstMethod() und SecondMethod(), die voneinander unabhängig sind und die FirstMethod() lange braucht, um ihre Aufgabe zu erfüllen.

Die synchrone Programmierung beginnt mit FirstMethod() und wartet auf deren Ende, bevor sie mit SecondMethod() fortfährt, die dann ausgeführt wird. Auch wenn beide Verfahren unabhängig voneinander sind, wird der Prozess viel Zeit in Anspruch nehmen.

Wir können alle Funktionen gleichzeitig ausführen, indem wir einfache Thread-Programmierung verwenden, aber dies würde die Benutzeroberfläche blockieren, während wir auf die Beendigung der Aufgaben warten. Bei der traditionellen Programmierung müssten wir viel Code schreiben, um dieses Problem zu lösen, aber wenn wir die Schlüsselwörter async und await verwenden, können wir das Problem mit viel weniger Code lösen.

Wir werden auch andere Beispiele sehen, und in diesen Fällen, wenn SecondMethod() von FirstMethod() abhängt, wird es das Schlüsselwort await verwenden, um darauf zu warten, dass FirstMethod() seine Ausführung beendet.

In C# sind async und await Codemarkierungen, die angeben, wohin das Steuerelement zurückkehren soll, wenn eine Aufgabe abgeschlossen ist.

Beginnen Sie mit realen Beispielen, um die Programmierung dahinter besser zu verstehen. Sehen Sie sich den folgenden Code an.

class Program {
  static void Main(string[] args) {
    FirstMethod();
    SecondMethod();
    Console.ReadKey();
  }

  public static async Task FirstMethod() {
    await Task.Run(() => {
      for (int i = 0; i < 100; i++) {
        Console.WriteLine(" First Method");
        // Do something
        Task.Delay(100).Wait();
      }
    });
  }

  public static void SecondMethod() {
    for (int i = 0; i < 25; i++) {
      Console.WriteLine(" Second Method ");
      // Do something
      Task.Delay(100).Wait();
    }
  }
}

Die Ausgabe des obigen Codes sieht wie folgt aus.

First Method
Second Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
Second Method
Second Method
Second Method
Second Method

Wie Sie im obigen Code sehen können, stoppt das ganze Programm nicht, nur weil wir die Ausführung eines Threads stoppen müssen. Beide können gleichzeitig mit der Verwendung von asynchroner Programmierung ausgeführt werden.

Angenommen, Sie befinden sich an einem Punkt, an dem Sie einige API-Daten abrufen müssen, was einige Zeit in Anspruch nimmt. Das Programm bewegt sich also zur nächsten Zeile, ohne die Daten zu erhalten, also müssen wir es etwas verzögern, um diese Daten zu erhalten, und dann zur nächsten Zeile übergehen.