C#-Thread

Der folgende Artikel enthält eine Übersicht für den C#-Thread. Der Ausführungspfad des Programms ist als Thread definiert und jeder Thread definiert einen eindeutigen Kontrollfluss. Wenn die Anwendung komplizierte und zeitaufwändige Vorgänge umfasst, müssen verschiedene Ausführungspfade oder Threads festgelegt werden, wobei jeder Thread für einen bestimmten Job verantwortlich ist. Diese Thread-Prozesse sind leichtgewichtig und die modernen Betriebssysteme implementieren die gleichzeitige Programmierung. Dies ist eines der Beispiele für die Verwendung von Threads. Durch die Verwendung von Threads werden Zyklusverluste der zentralen Verarbeitungseinheit eingespart und die Effizienz der Anwendung erhöht.

Syntax:

public sealed class Thread: System.Runtime.ConstrainedExecution.CriticalFinalizerObject

Funktionsweise der C#-Thread-Klasse

Die Zeit, zu der ein Objekt der System.Threading.Thread-Klasse erstellt wird, wenn der Lebenszyklus des Threads beginnt. Wenn der Thread beendet oder die Ausführung des Threads abgeschlossen ist, wird der Thread erstellt und beendet.

Es gibt mehrere Zustände im Lebenszyklus eines Threads.

1. Der nicht gestartete Zustand: Dieser Zustand ist eine Situation, in der die Startmethode nicht aufgerufen, aber eine Instanz des Threads erstellt wird.

2. Der Bereitschaftszustand: Dieser Zustand ist eine Situation, in der der Thread vollständig auf die Ausführung eingestellt ist und auf den Zyklus der Zentraleinheit wartet.

3. Der Status „Nicht ausführbar“: Dieser Status ist eine Situation, in der der Thread nicht ausgeführt werden kann, wenn:

• Die Sleep-Methode wurde aufgerufen.
• Die Wait-Methode wurde aufgerufen.
• Es gab eine Blockierung durch Ein-/Ausgabevorgänge.

4. Der tote Zustand: Dieser Zustand ist eine Situation, in der die Ausführung des Threads abgeschlossen ist oder die Ausführung des Threads abgebrochen wird.

• Um mit Threads in C# arbeiten zu können, müssen wir die Klasse System.Threading.Thread verwenden.
• Während der Arbeit mit Multithread-Anwendungen können einzelne Threads mithilfe der System.Threading.Thread-Klasse in C# erstellt und aufgerufen werden.
• Der Thread, der im gesamten Prozess zuerst ausgeführt wird, wird als Hauptthread bezeichnet.
• Der Hauptthread wird automatisch erstellt, wenn die Ausführung des C#-Programms beginnt.
• Die Threads, die mithilfe der Thread-Klassen erstellt werden, werden als untergeordnete Threads des Hauptthreads bezeichnet.
• Die CurrentThread-Eigenschaft der Thread-Klasse wird für den Zugriff auf einen Thread verwendet.

Das folgende Programm demonstriert die Ausführung des Hauptthreads:

Code:

using System;
using System.Threading;
//a namespace called multithreading is created
namespace Multithreading
{
//a class called mainthread is created under multithreading namespace
class MainThread
{
//main method is called
static void Main(string[] args)
{
//an instance of the thread class is created
Thread thr = Thread.CurrentThread;
//Name method of thread class is accessed using the instance of the thread class
thr.Name = "Thread Class";
//the content is displayed as the output
Console.WriteLine("Welcome to {0}", thr.Name);
Console.ReadKey();
}
}
}

Ausgabe:

Im obigen Programm wird ein Namespace namens Multithreading erstellt. Anschließend wird eine Klasse namens mainthread im Multithreading-Namespace erstellt. Dann wird eine Hauptmethode aufgerufen. Anschließend wird eine Instanz der Thread-Klasse erstellt. Dann wird über die Instanz der Thread-Klasse auf die Name-Methode der Thread-Klasse zugegriffen. Abschließend wird die Ausgabe auf dem Bildschirm angezeigt.

Methoden der Thread-Klasse

Im Folgenden sind die verschiedenen Methoden der Thread-Klasse aufgeführt:

1. Abort()

Immer wenn die Abort()-Methode für einen Thread aufgerufen wird, wird ThreadAbortException ausgelöst und der Prozess der Beendigung des Threads beginnt. Die Beendigung des Threads wird durch den Aufruf dieser Methode verursacht.

Beispiel: 

Code:

using System;
using System.Threading;
class ExThread
{
public void thr()
{
for (int y = 0; y < 3; y++)
{
Console.WriteLine(y);
}
}
}
class Example
{
public static void Main()
{
ExThread ob = new ExThread();
Thread th = new Thread(new ThreadStart(ob.thr));
th.Start();
Console.WriteLine("Aborting the thread");
th.Abort();
}
}

Ausgabe:

2. Interrupt()

Immer wenn die Interrupt()-Methode aufgerufen wird, wird ein Thread, der sich im Thread-Status von WaitSleepJoin befindet, unterbrochen.

3. Join()

Immer wenn die Join()-Methode aufgerufen wird, wird ein aufrufender Thread blockiert, bis ein Thread beendet wird und das Standard-COM- und SendMessage-Pumpen zusammen mit der Blockierung des Threads weiter ausgeführt wird.

Beispiel zur Implementierung von Interrupt() und Join():

Code:

using System;
using System.Threading;
class Thr
{
Thread th;
public Thr(String name1)
{
th = new Thread(this.Runaway);
th.Name = name1;
th.Start();
}
public void Runaway()
{
Thread th1 = Thread.CurrentThread;
try
{
Console.WriteLine(" Execution of " + th1.Name + " has begun");
for(int y=0; y<3; y++)
{
Console.WriteLine(" Printing of " + th1.Name + " has begun" + y);
Thread.Sleep(200);
}
Console.WriteLine(" Execution of " + th1.Name + " is finished");
}
catch(ThreadInterruptedException e)
{
Console.WriteLine("Thread Interruption" + e);
}
}
public static void Main(String[] ar)
{
Thr ob = new Thr("Thread demo");
ob.th.Interrupt();
ob.th.Join();
}
}

Ausgabe:

4. ResetAbort()

Immer wenn die ResetAbort()-Methode aufgerufen wird, wird die Beendigungsanforderung für den aktuellen Thread abgebrochen.

Beispiel:

Code:

using System;
using System.Threading;
using System.Security.Permissions;
class Thread1
{
public void Jobthread()
{
try
{
for (int r = 0; r < 3; r++)
{
Console.WriteLine(" Working of thread has begun ");
Thread.Sleep(10);
}
}
catch (ThreadAbortException e)
{
Console.WriteLine("ThreadAbortException is caught and must be reset");
Console.WriteLine("The message looks like this: {0}", e.Message);
Thread.ResetAbort();
}
Console.WriteLine("Thread is working fine");
Thread.Sleep(200);
Console.WriteLine("Thread is done");
}
}
class Driver
{
public static void Main()
{
Thread1 obj = new Thread1();
Thread Th = new Thread(obj.Jobthread);
Th.Start();
Thread.Sleep(100);
Console.WriteLine("thread abort");
Th.Abort();
Th.Join();
Console.WriteLine("end of main thread");
}
}

Ausgabe:

5. Start()

Immer wenn die Methode Start() aufgerufen wird, wird ein Thread gestartet.

Beispiel:

Code:

using System;
using System.Threading;
class Test
{
static void Main()
{
Thread td = new Thread (new ThreadStart (Got));
td.Start();
}
static void Got()
{
Console.WriteLine ("this is thread Start() method");
}
}

Ausgabe:

6. Sleep(int millisecondsTimeout)

Immer wenn die Sleep(int millisecondsTimeout)-Methode aufgerufen wird, wird der Thread für den angegebenen Zeitraum angehalten.

Beispiel:

Code:

using System;
using System.Threading;
namespace Examplethr
{
class MyThread
{
static void Main(string[] args)
{
Thread th = Thread.CurrentThread;
th.Name = "This is the First Thread";
Console.WriteLine("The Name of the thread is : {0}", th.Name);
Console.WriteLine("The priority of the thread is : {0}", th.Priority);
Console.WriteLine("Pausing the child thread");
// using Sleep() method
Thread.Sleep(100);
Console.WriteLine("Resuming the child thread");
Console.ReadKey();
}
}
}

Ausgabe:

7. Suspend()

Whenever Suspend() method is called, the current thread is suspended if it is not suspended.

8. Resume()

Whenever Resume() method is called, the suspended thread is resumed.

9. Yield()

Whenever Yield() method is called, the calling thread must result in execution to the other thread which is ready to start running on the current processor. The thread to yield to is selected by the operating system.

Example to implement Suspend() Resume() and Yield()

Code:

using System;
using System.Runtime.CompilerServices;
using System.Threading;
class Program
{
public static void Main ()
{
bool finish = false;
Thread th = new Thread (() => {
while (!finish) {}
});
Thread th1 = new Thread (() => {
while (!finish) {
GC.Collect ();
Thread.Yield ();
}
});
th.Start ();
th1.Start ();
Thread.Sleep (10);
for (int j = 0; j < 5 * 4 * 2; ++j) {
th.Suspend ();
Thread.Yield ();
th.Resume ();
if ((j + 1) % (5) == 0)
Console.Write ("Hello ");
if ((j + 1) % (5 * 4) == 0)
Console.WriteLine ();
}
finish = true;
th.Join ();
th1.Join ();
}
}

Output:

Das obige ist der detaillierte Inhalt vonC#-Thread. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!