So arbeiten Sie mit Threads in C #

Ein Thread ist die kleinste Ausführungseinheit innerhalb eines Prozesses. Multithreading ist die Fähigkeit, mehrere Threads gleichzeitig im Speicher zu haben und zwischen ihnen zu wechseln, um mehrere Operationen gleichzeitig auszuführen. Das .NET Framework von Microsoft bietet hervorragende Unterstützung für die Arbeit mit Threads.

Programmieren von Threads in C #

Um mit Threads arbeiten zu können, sollten Sie den System.Threading-Namespace in Ihre Anwendung aufnehmen. Um einen neuen Thread zu erstellen, sollten Sie den ThreadStart-Delegaten nutzen und den Verweis an eine Methode übergeben, die auf dem Thread ausgeführt werden soll. Beachten Sie, dass ein Delegat ein typsicherer Funktionszeiger ist. Das folgende Codefragment zeigt, wie Sie mit diesem Delegaten ein neues Thread-Objekt erstellen können.

 Thread t = neuer Thread (neuer ThreadStart (MyThreadMethod)); 

Um den neu erstellten Thread zu starten, sollten Sie die Start-Methode für das von Ihnen erstellte Thread-Objekt aufrufen. Die folgende Codeliste veranschaulicht dies. Beachten Sie, dass die Thread-Methode MyThreadMethod für den neuen Thread (als Arbeitsthread bezeichnet) ausgeführt wird, der erstellt wurde.

 statische Leere Main ()

        {

            Thread t = neuer Thread (neuer ThreadStart (MyThreadMethod));

            t.Start ();           

            Console.Read ();

        }}

        statische Leere MyThreadMethod ()

        {

            Console.WriteLine ("Hallo Welt!");

        }}

Thread-Zustände in C # anzeigen

Ein Thread im Speicher kann sich in verschiedenen Zuständen befinden: Abgebrochen, Hintergrund, Ausführen, Gestoppt, Angehalten, Nicht gestartet usw. Thread-Zustände werden in der ThreadState-Aufzählung definiert, die im System.Threading-Namespace verfügbar ist. Sofern die Start-Methode nicht für einen Thread aufgerufen wird, befindet sich der Thread im Status "Nicht gestartet". Wenn die Start-Methode für die Thread-Instanz aufgerufen wird, ändert sich der Status des Threads von "Nicht gestartet" in "Wird ausgeführt".

Das folgende Codefragment zeigt, wie Sie den Status eines Threads in der Konsole anzeigen können.

 Thread t = neuer Thread (neuer ThreadStart (MyThreadMethod));

t.Start ();

Console.WriteLine („Der Status des Threads lautet:“ + t.ThreadState.ToString ());

Steuern Sie Vordergrund- und Hintergrund-Threads in C #

Threads können entweder im Vordergrund oder im Hintergrund ausgeführt werden. Die Threads, die Sie explizit erstellen, sind Vordergrund-Threads. Einer der Hauptunterschiede zwischen einem Vordergrund-Thread und einem Hintergrund-Thread besteht darin, dass Ihre Anwendung nur so lange lebt, wie ein oder mehrere Vordergrund-Threads ausgeführt werden. Im Wesentlichen verhindern Vordergrund-Threads, dass die Anwendung beendet wird. Im Gegensatz dazu halten Hintergrundthreads die Common Language Runtime-Umgebung nicht am Leben.

Sie können den Hintergrundstatus eines Threads mithilfe der IsBackground-Eigenschaft festlegen. Hier ist ein Codebeispiel, das zeigt, wie dies erreicht werden kann.

 statische Leere Main ()

        {

            Thread t = neuer Thread (neuer ThreadStart (MyThreadMethod));

            t.Start ();

            t.IsBackground = true;

            Console.WriteLine („Der Hintergrundstatus des Threads lautet:“ + t.IsBackground.ToString ());

            Console.Read ();

        }}

Sie können einen Thread anhalten oder fortsetzen, indem Sie die Methoden Suspend () und Resume () für das Thread-Objekt aufrufen. Beachten Sie, dass Sie einen zuvor angehaltenen Thread nur fortsetzen können, indem Sie die Suspend () -Methode aufrufen.

 Thread t = neuer Thread (neuer ThreadStart (MyThreadMethod));

t.Start ();

t.Suspend (); // Hält den neu erstellten Thread an

t.Resume (); // Setzt den angehaltenen Thread fort

Es ist jedoch zu beachten, dass die Methoden Thread.Suspend () und Thread.Resume () veraltet sind. Verwenden Sie stattdessen die Methoden AutoResetEvent und EventWaitHandle, um Aktivitäten mit Threads zu synchronisieren.

Legen Sie die Thread-Priorität in C # fest

Sie können die Priorität eines Threads steuern, um den relativen Anteil der Prozessorzeit zu bestimmen, den ein Thread im Vergleich zu den anderen im Speicher befindlichen Threads erhält. Die Thread-Priorität wird in der ThreadPriority-Enumeration definiert. Die möglichen Werte umfassen: Niedrigste, Unter Normal, Normal, Über Normal und Höchste. Das folgende Codeausschnitt zeigt, wie Sie die Thread-Prioritäten von zwei Threads mithilfe der Priority-Eigenschaft des Thread-Objekts festlegen können.

 statische Leere Main ()

        {

            Thread thread1 = neuer Thread (neuer ThreadStart (Methode1));

            Thread thread2 = neuer Thread (neuer ThreadStart (Methode2));

            thread1.Priority = ThreadPriority.Highest;

            thread2.Priority = ThreadPriority.Lowest;

            thread2.Start ();

            thread1.Start ();

            Console.Read ();

        }}

        statische Leere Methode1 ()

        {

            für (int i = 0; i <10; i ++)

            {

                Console.WriteLine („Erster Thread:“ + i);

            }}

        }}

        statische Leere Methode2 ()

        {

            für (int i = 0; i <10; i ++)

            {

                Console.WriteLine („Zweiter Thread:“ + i);

            }}

        }}

Wenn Sie das obige Codefragment ausführen, sehen Sie, dass der erste Thread seine Ausführung vor dem zweiten Thread abschließt, obwohl der zweite Thread vor dem ersten Thread in der Main-Methode gestartet wurde.

Fäden sind teuer. Sie verbrauchen viele Ressourcen in Ihrem System, um sie zu initialisieren, den Kontext zu wechseln und die von ihnen verbrauchten Ressourcen freizugeben. Folglich sollte Multithreading mit Bedacht und nur dann eingesetzt werden, wenn es benötigt wird. Wenn Sie Multithreading nutzen, ist es immer ratsam, Thread-Pools zu nutzen, um Threads bei Bedarf zu erstellen und zu verwalten und die Reaktionsfähigkeit Ihrer Anwendung zu verbessern.