Latest web development tutorials

C # Multithreading

Thema ist als Ausführungspfad des Programms definiert.Jeder Thread definiert eine einzigartige Steuerungsfluss. Wenn Ihre Anwendung komplexer und zeitaufwendiger Vorgang beinhaltet verschiedene Ausführungspfade setzen oft nützlich Faden ist, führt jeder Thread eine bestimmte Aufgabe.

Themen sindleicht Prozesse.Ein gängiges Beispiel ist die Verwendung von Threads parallel Programmierung moderner Betriebssystemimplementierung. Verwenden Sie Threads zu speichern Abfall CPU-Zyklen, während die Effizienz der Anwendung zu verbessern.

Bisher haben wir ein Programm vorbereitet ein einzelner Prozess ist als ein Single-Thread-Anwendungsinstanz laufen läuft. Jedoch mit einer solchen Anwendung kann nur eine Aufgabe in der gleichen Zeit durchführen. Um gleichzeitig mehrere Aufgaben auszuführen, kann es in kleineren Gewinde unterteilt werden.

Thema Life Cycle

Themen-Lebenszyklus beginnt System.Threading.Thread Klassenobjekt erstellt wird, das Ende beendet wird oder in der Ausführungs-Thread abgeschlossen.

Die folgende Liste zeigt den Status des Themas Lebenszyklus:

  • Der Staat wird nicht gestartet:Wenn ein Thread - Instanz erstellt wird, das Verfahren ist aber nicht Startbedingung genannt.
  • Ready - Zustand:bereit zu laufen , wenn der Thread für CPU - Zyklen und Bedingungen wartet.
  • Nicht-Betriebszustand: Die folgenden Situationen sind nicht unter dem Thread ausgeführt:

    • Das Verfahren wurde genannte Schlaf
    • Das Verfahren wurde genannt Wait
    • Durch die I / O-Operationen Behinderung
  • DerTod Status: Wenn der Thread hat abgeschlossen Ausführung oder abgebrochen Status , wenn.

Hauptthread

In C# System.Threading.Thread Klasse für Gewindearbeiten.Es ermöglicht Ihnen, eine Multithread-Anwendung in einem einzigen Thread zu erstellen und darauf zugreifen. Der erste Thread in dem Prozess ausgeführt werden soll ,wird das primäre Thread aufgerufen.

Wenn ein C # Programmausführung beginnt, wird der Hauptthread automatisch erstellt. Verwenden Sie dieThread - Klasse einen Thread erstellen , ist der Haupt - Thread Kind Thread aufgerufen.Sie können die Klasse ThreadCurrent Eigenschaft Zugriff Thread verwenden.

Das folgende Programm zeigt die Ausführung des Haupt-Thread:

using System;
mit System.Threading;

Namespace MultithreadingApplication
{
    Klasse MainThreadProgram
    {
        static void Main (string [] args)
        {
            Thema th = Thread.currentThread;
            th.Name = "Mainthread";
            Console.WriteLine ( "Das ist {0}", th.Name);
            Console.ReadKey ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Dies ist Mainthread

Thread-Klasse gemeinsame Attribute und Methoden

Die folgende Tabelle listet die KlasseThread einige gemeinsame Attribute:

属性描述
CurrentContext获取线程正在其中执行的当前上下文。
CurrentCulture获取或设置当前线程的区域性。
CurrentPrinciple获取或设置线程的当前负责人(对基于角色的安全性而言)。
CurrentThread获取当前正在运行的线程。
CurrentUICulture获取或设置资源管理器使用的当前区域性以便在运行时查找区域性特定的资源。
ExecutionContext获取一个 ExecutionContext 对象,该对象包含有关当前线程的各种上下文的信息。
IsAlive获取一个值,该值指示当前线程的执行状态。
IsBackground获取或设置一个值,该值指示某个线程是否为后台线程。
IsThreadPoolThread获取一个值,该值指示线程是否属于托管线程池。
ManagedThreadId获取当前托管线程的唯一标识符。
Name获取或设置线程的名称。
Priority获取或设置一个值,该值指示线程的调度优先级。
ThreadState获取一个值,该值包含当前线程的状态。

Die folgende Tabelle listet die KlasseThread einige häufig verwendete Methoden:

序号方法名 & 描述
1public void Abort()
在调用此方法的线程上引发 ThreadAbortException,以开始终止此线程的过程。调用此方法通常会终止线程。
2public static LocalDataStoreSlot AllocateDataSlot()
在所有的线程上分配未命名的数据槽。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。
3public static LocalDataStoreSlot AllocateNamedDataSlot( string name)
在所有线程上分配已命名的数据槽。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。
4public static void BeginCriticalRegion()
通知主机执行将要进入一个代码区域,在该代码区域内线程中止或未经处理的异常的影响可能会危害应用程序域中的其他任务。
5public static void BeginThreadAffinity()
通知主机托管代码将要执行依赖于当前物理操作系统线程的标识的指令。
6public static void EndCriticalRegion()
通知主机执行将要进入一个代码区域,在该代码区域内线程中止或未经处理的异常仅影响当前任务。
7public static void EndThreadAffinity()
通知主机托管代码已执行完依赖于当前物理操作系统线程的标识的指令。
8public static void FreeNamedDataSlot(string name)
为进程中的所有线程消除名称与槽之间的关联。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。
9public static Object GetData( LocalDataStoreSlot slot )
在当前线程的当前域中从当前线程上指定的槽中检索值。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。
10public static AppDomain GetDomain()
返回当前线程正在其中运行的当前域。
11public static AppDomain GetDomainID()
返回唯一的应用程序域标识符。
12public static LocalDataStoreSlot GetNamedDataSlot( string name )
查找已命名的数据槽。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。
13public void Interrupt()
中断处于 WaitSleepJoin 线程状态的线程。
14public void Join()
在继续执行标准的 COM 和 SendMessage 消息泵处理期间,阻塞调用线程,直到某个线程终止为止。此方法有不同的重载形式。
15public static void MemoryBarrier()
按如下方式同步内存存取:执行当前线程的处理器在对指令重新排序时,不能采用先执行 MemoryBarrier 调用之后的内存存取,再执行 MemoryBarrier 调用之前的内存存取的方式。
16public static void ResetAbort()
取消为当前线程请求的 Abort。
17public static void SetData( LocalDataStoreSlot slot, Object data )
在当前正在运行的线程上为此线程的当前域在指定槽中设置数据。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。
18public void Start()
开始一个线程。
19public static void Sleep( int millisecondsTimeout )
让线程暂停一段时间。
20public static void SpinWait( int iterations )
导致线程等待由 iterations 参数定义的时间量。
21public static byte VolatileRead( ref byte address )
public static double VolatileRead( ref double address )
public static int VolatileRead( ref int address )
public static Object VolatileRead( ref Object address )

读取字段值。无论处理器的数目或处理器缓存的状态如何,该值都是由计算机的任何处理器写入的最新值。此方法有不同的重载形式。这里只给出了一些形式。
22public static void VolatileWrite( ref byte address, byte value )
public static void VolatileWrite( ref double address, double value )
public static void VolatileWrite( ref int address, int value )
public static void VolatileWrite( ref Object address, Object value )

立即向字段写入一个值,以使该值对计算机中的所有处理器都可见。此方法有不同的重载形式。这里只给出了一些形式。
23public static bool Yield()
导致调用线程执行准备好在当前处理器上运行的另一个线程。由操作系统选择要执行的线程。

Erstellen Sie einen Faden

Ein Faden wird durch die Verlängerung der Thread-Klasse erstellt. Vorstand Erweiterter Thread - Klasse ruft die MethodeStart () die untergeordneten Threads zu starten.

Das folgende Programm veranschaulicht dieses Konzept:

using System;
mit System.Threading;

Namespace MultithreadingApplication
{
    Klasse ThreadCreationProgram
    {
        public static void CallToChildThread ()
        {
            Console.WriteLine ( "Child Faden beginnt");
        }
        
        static void Main (string [] args)
        {
            Thread childref = new Threadstart (CallToChildThread);
            Console.WriteLine ( "In Main: Erstellen des Child-Thread");
            Gewinde childThread = new Thread (childref);
            childThread.Start ();
            Console.ReadKey ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Im Main: Erstellen des Kinder Faden
Kinder Faden beginnt

Verwalten Thema

Thread Thread-Klasse bietet eine Vielzahl von Management-Methoden.

Das folgende Beispiel zeigt die Verwendung vonsleep () Methode wird in einem bestimmten Zeitüberschreitungs Thread verwendet.

using System;
mit System.Threading;

Namespace MultithreadingApplication
{
    Klasse ThreadCreationProgram
    {
        public static void CallToChildThread ()
        {
            Console.WriteLine ( "Child Faden beginnt");
            // Thema ist auf 5000 Millisekunden int suspendiert sleepfor = 5000; 
            Console.WriteLine ( "Child Thema Pausiert für {0} Sekunden", 
                              sleepfor / 1000);
            Thread.Sleep (sleepfor);
            Console.WriteLine ( "Child Faden wieder aufnimmt");
        }
        
        static void Main (string [] args)
        {
            Thread childref = new Threadstart (CallToChildThread);
            Console.WriteLine ( "In Main: Erstellen des Child-Thread");
            Gewinde childThread = new Thread (childref);
            childThread.Start ();
            Console.ReadKey ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Im Main: Erstellen des Kinder Faden
Kinder Faden beginnt
Kinder Thema pausiert für 5 Sekunden
Kinder Faden wieder aufgenommen

Zerstört Fäden

Abort () -Methode wird verwendet , Fäden zu zerstören.

Indem erThread abbrechen Threads zur Laufzeit.Diese Ausnahme kann nicht gefangen werden, wennschließlichblockieren, wird die SteuerungschließlichBlock gesendet werden.

Das folgende Programm veranschaulicht diesen Punkt:

using System;
mit System.Threading;

Namespace MultithreadingApplication
{
    Klasse ThreadCreationProgram
    {
        public static void CallToChildThread ()
        {
            versuchen
            {

                Console.WriteLine ( "Child Faden beginnt");
                // Bis 10 Count
                for (int counter = 0; Zähler <= 10; Zähler ++)
                {
                    Thread.Sleep (500);
                    Console.WriteLine (Zähler);
                }
                Console.WriteLine ( "Child Thema abgeschlossen");

            }
            catch (Threadabort e)
            {
                Console.WriteLine ( "Thread Abort Exception");
            }
            schließlich
            {
                Console.WriteLine ( "Konnte das Thema Exception fangen");
            }

        }
        
        static void Main (string [] args)
        {
            Thread childref = new Threadstart (CallToChildThread);
            Console.WriteLine ( "In Main: Erstellen des Child-Thread");
            Gewinde childThread = new Thread (childref);
            childThread.Start ();
            Stopp // den Haupt-Thread für einige Zeit Thread.Sleep (2000);
            // Jetzt suspendierte Kind Faden Console.WriteLine ( "In Main: Das vorzeitige Beenden der Kinder Thread");
            childThread.Abort ();
            Console.ReadKey ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Im Main: Erstellen des Kinder Faden
Kinder Faden beginnt
0
1
2
Im Main: Das vorzeitige Beenden der Kinder Faden
Fädeln Abort Exception
Konnte das Thema Exception fangen