Latest web development tutorials

C # Multithreading

Discussione è definito come il percorso di esecuzione del programma.Ogni thread definisce un unico flusso di controllo. Se l'applicazione comporta un'operazione complessa e che richiede tempo, impostare diversi percorsi di esecuzione è spesso filo utile, ogni thread esegue un lavoro specifico.

Le discussioni sonoprocessi leggeri.Un esempio comune è l'utilizzo di fili in programmazione parallela di esecuzione moderna sistema operativo. Utilizzare fili risparmio cicli di CPU rifiuti, migliorando l'efficienza della domanda.

Finora abbiamo preparato un programma è un singolo processo per l'esecuzione come istanza a thread singolo applicazione è in esecuzione. Tuttavia, con tale applicazione può eseguire una sola operazione contemporaneamente. Per svolgere più attività contemporaneamente, può essere diviso in filo più piccolo.

Life Cycle Discussione

ciclo di vita del filo inizia si crea oggetto classe System.Threading.Thread, alla fine è terminato o completato nel thread di esecuzione.

Di seguito sono elencati lo stato del ciclo di vita del filo:

  • Lo Stato non parte: Quando si crea un'istanza di filo, ma il metodo non viene chiamato Inizio condizione.
  • stato di pronto: pronto a funzionare quando il thread è in attesa di cicli e condizioni di CPU.
  • stato di non-funzionamento: Le seguenti situazioni non vengono eseguiti sotto il filo:

    • Il metodo è stato chiamato sonno
    • Il metodo è stato chiamato Wait
    • Per operazioni di I / O ostruzione
  • La morte di stato: quando il thread ha completato l'esecuzione o lo stato interrotto quando.

thread principale

In C#, classe System.Threading.Thread per il lavoro thread.Esso consente di creare e accedere un'applicazione multithread in un singolo thread. Il primo thread nel processo da eseguireè chiamato il thread primario.

Quando un programma C # inizia l'esecuzione, viene creato automaticamente il thread principale. Utilizzare la classeThread per creare un thread è chiamato il principale thread figlio thread.È possibile utilizzare il filo accesso alle proprietàCurrentThread classe Thread.

Il seguente programma illustra l'esecuzione del thread principale:

using System;
utilizzando System.Threading;

namespace MultithreadingApplication
{
    classe MainThreadProgram
    {
        static void Main (string [] args)
        {
            Discussione esimo = Thread.currentThread;
            th.Name = "MainThread";
            Console.WriteLine ( "Questo è {0}", th.Name);
            Console.ReadKey ();
        }
    }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:

Questo è MainThread

classe thread attributi e metodi comuni

La seguente tabella elenca classeThread alcuni attributi comuni:

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

La seguente tabella elenca classeThread alcuni metodicomunementeusati:

序号方法名 & 描述
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()
导致调用线程执行准备好在当前处理器上运行的另一个线程。由操作系统选择要执行的线程。

Creare un filo

Un thread è creato estendendo la classe Thread. Esecutivo classe Thread esteso chiama il metodoStart () per avviare i thread figlio.

Il seguente programma illustra questo concetto:

using System;
utilizzando System.Threading;

namespace MultithreadingApplication
{
    classe ThreadCreationProgram
    {
        CallToChildThread public static void ()
        {
            Console.WriteLine ( "filettatura inizia Child");
        }
        
        static void Main (string [] args)
        {
            ThreadStart childref = new ThreadStart (CallToChildThread);
            Console.WriteLine ( "In principale: Creazione del filo Bambino");
            Infilare childThread = new Thread (childref);
            childThread.Start ();
            Console.ReadKey ();
        }
    }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:

Nel principale: Creazione del filo Bambino
inizia thread figlio

Gestione Discussione

classe Thread Discussione fornisce una varietà di metodi di gestione.

L'esempio seguente dimostra l'uso del metodosleep () viene utilizzato in un thread specifico time-out.

using System;
utilizzando System.Threading;

namespace MultithreadingApplication
{
    classe ThreadCreationProgram
    {
        CallToChildThread public static void ()
        {
            Console.WriteLine ( "filettatura inizia Child");
            // Thread viene sospeso a 5000 millisecondi int sleepfor = 5000; 
            Console.WriteLine ( "thread figlio fermò per {0} secondi", 
                              sleepfor / 1000);
            Thread.Sleep (sleepfor);
            Console.WriteLine ( "filo Bambino riprende");
        }
        
        static void Main (string [] args)
        {
            ThreadStart childref = new ThreadStart (CallToChildThread);
            Console.WriteLine ( "In principale: Creazione del filo Bambino");
            Infilare childThread = new Thread (childref);
            childThread.Start ();
            Console.ReadKey ();
        }
    }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:

Nel principale: Creazione del filo Bambino
inizia thread figlio
Discussione Bambino In pausa per 5 secondi
riprende thread figlio

distrugge le discussioni

metodoAbort () viene utilizzato per distruggere le discussioni.

GettandoThreadAbortException interrompere le discussioni in fase di esecuzione.Questa eccezione non può essere catturato, se allafinedi bloccare, il controllo verrà inviato bloccofinally.

Il seguente programma illustra questo punto:

using System;
utilizzando System.Threading;

namespace MultithreadingApplication
{
    classe ThreadCreationProgram
    {
        CallToChildThread public static void ()
        {
            provare
            {

                Console.WriteLine ( "filettatura inizia Child");
                // Contare fino a 10
                per (contatore int = 0; contatore <= 10; contatore ++)
                {
                    Thread.Sleep (500);
                    Console.WriteLine (contatore);
                }
                Console.WriteLine ( "thread figlio Completato");

            }
            catch (ThreadAbortException e)
            {
                Console.WriteLine ( "Discussione Abort Exception");
            }
            infine
            {
                Console.WriteLine ( "Impossibile intercettare l'eccezione del filo");
            }

        }
        
        static void Main (string [] args)
        {
            ThreadStart childref = new ThreadStart (CallToChildThread);
            Console.WriteLine ( "In principale: Creazione del filo Bambino");
            Infilare childThread = new Thread (childref);
            childThread.Start ();
            // Arrestare il thread principale per un certo tempo Thread.Sleep (2000);
            // Ora sospesa thread figlio Console.WriteLine ( "In Principale: Interruzione del thread figlio");
            childThread.Abort ();
            Console.ReadKey ();
        }
    }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:

Nel principale: Creazione del filo Bambino
inizia thread figlio
0
1
2
Nel principale: Interruzione del thread figlio
Discussione Abort Exception
Impossibile intercettare l'eccezione Discussione