Explication détaillée de la classe Thread pour le multi-threading en C#

Utilisez la classe System.Threading.Thread pour créer et contrôler des threads.

Les constructeurs couramment utilisés sont :

        // 摘要: //     初始化 System.Threading.Thread 类的新实例，指定允许对象在线程启动时传递给线程的委托。//// 参数: //   start://     System.Threading.ParameterizedThreadStart 委托，它表示此线程开始执行时要调用的方法。//// 异常: //   System.ArgumentNullException://     start 为 null。        [SecuritySafeCritical]public Thread(ParameterizedThreadStart start);//// 摘要: //     初始化 System.Threading.Thread 类的新实例。//// 参数: //   start://     System.Threading.ThreadStart 委托，它表示此线程开始执行时要调用的方法。//// 异常: //   System.ArgumentNullException://     start 参数为 null。        [SecuritySafeCritical]public Thread(ThreadStart start);

1. Créer un fil de discussion sans paramètres

Délégué ThreadStart définit une méthode sans paramètre avec un type de retour void.

        public void Main()
        {
            Thread vThread = new Thread(ThreadFun);//vThread.Name = "td_Name";  // 线程名称vThread.Start(); //开始执行线程Console.WriteLine("This is the main thread:id=" + Thread.CurrentThread.ManagedThreadId);
        }void ThreadFun() // 来自委托：ThreadStart         {
            Console.WriteLine("Running in a new thread:id=" + Thread.CurrentThread.ManagedThreadId);for (int i = 0; i < 10; i++)
            {
                Console.Write(".");
                Thread.Sleep(500);
            }
            Console.WriteLine("THREAD END");
        }

Résultat de sortie :

Utilisez ThreadFun() dans le code d'appel avec

Expression Lambda Remplacez par la manière simple d'utiliser Thread :

        public void Main()
        {
            Thread vThread = new Thread(() =>{
                Console.WriteLine("Running in a new thread");});//vThread.Name = "td_Name";  // 线程名称vThread.Start(); //开始执行线程Console.WriteLine("This is the main thread");
        }

2. Transmettez les paramètres au fil

Deux façons : l'une consiste à construire Thread en utilisant des paramètres de méthode avec

ParameterizedThreadStartDelegate ; l'autre consiste à créer une classe personnalisée et à définir le thread ; méthode en tant que méthode d'instance, de sorte que les données d'instance soient d'abord initialisées, puis le thread est démarré.

Par exemple : passer des paramètres

        public struct TdData // 传递数据        {public string Message;  //数据string字段}

Utiliser la première méthode :

        public void Main()
        {
            TdData tData = new TdData() { Message = "Thread Info" };
            Thread vThread = new Thread(ThreadFun);
            vThread.Start(tData);   // 开始执行线程,传递参数Console.WriteLine("This is the main thread");
        }void ThreadFun(object pObj) // 来自委托：ParameterizedThreadStart         {
            TdData vData = (TdData)pObj;
            Console.WriteLine("In a new thread, Received:{0}", vData.Message);            
        }

Utilisez la deuxième méthode : personnalisez d'abord une classe.

    public class TdHelper
    {public TdData mData; // 传递数据// 构造函数public TdHelper(TdData pData)
        {this.mData = pData;
        }public void ThreadFun() // 来自委托：ThreadStart         {
            Console.WriteLine("In a new thread, TdDataMessage:{0}", mData.Message);
        }
    }

Ensuite, créez Thread dans le thread principal (si nécessaire) et utilisez la méthode d'instance

TdHelper.ThreadFun() comme paramètre du constructeur.

        public void Main()
        {
            TdData tData = new TdData() { Message = "Thread Info" };
            TdHelper tHelper = new TdHelper(tData); // 传递参数Thread vThread = new Thread(tHelper.ThreadFun);
            vThread.Start();
            Console.WriteLine("This is the main thread");
        }

3. Fil de fond

Par défaut, le thread créé par la classe Thread est un thread de premier plan et les threads du pool de threads sont toujours des threads d'arrière-plan. Tant qu'un thread de premier plan est en cours d'exécution, le processus d'application est en cours d'exécution. Si plusieurs threads de premier plan sont en cours d'exécution et que la méthode Main() se termine, l'application reste active jusqu'à ce que tous les threads de premier plan terminent leurs tâches.

Vous pouvez définir l'attribut

IsBackground de l'instance de classe Thread pour en faire un fil d'arrière-plan

        public void Main()
        {
            Thread vThread = new Thread(() =>{
                Console.WriteLine("New thread started");  // Title3Thread.Sleep(5000);
                Console.WriteLine("New thread completed"); // Title2});//vThread.IsBackground = true;            vThread.Start();
            Console.WriteLine("This is the main thread"); // Title1}

Lorsque la propriété IsBackground

est définie par défaut sur false , vous pouvez voir les 3 phrases d'informations de sortie entièrement dans la console, mais si elle est définie sur sur true , ce ne sera pas le cas Au moment où le troisième message (Titre2) est affiché, le thread principal Main() a terminé son exécution et la fenêtre de la console est automatiquement fermée.

4. Priorité du thread Grâce à l'attribut Priority, vous pouvez ajuster la priorité de l'instance de classe Thread. La valeur par défaut est : vThread. Priority = ThreadPriority.Normal; // Valeur d'énumération

Relation : la plus élevée > au-dessus de la normale > normale >

Appelez la méthode Start() de l'objet Thread pour créer un fil de discussion. Cependant, après avoir appelé la méthode Start(), le nouveau thread n'est toujours pas à l'état Running, mais à l'état Unstarted. Le thread passera à l'état En cours d'exécution uniquement si le planificateur de threads du système d'exploitation choisit d'exécuter le thread. Grâce à la propriété Thread.ThreadState, vous pouvez obtenir l'état actuel du thread.

L'utilisation de la méthode Thread.Sleep() mettra le thread dans l'état WaitSleepJoin. Après la période de temps définie par la méthode Sleep(), le thread attendra d'être à nouveau planifié par le système d'exploitation. Pour arrêter un thread, vous pouvez appeler la méthode Thread.Abort(). L'appel de cette méthode lancera une ThreadAbortException dans le thread qui reçoit la commande de terminaison. Utilisez un gestionnaire pour intercepter cette exception, et le thread pourra effectuer un travail de nettoyage avant de se terminer. Un thread peut également continuer à fonctionner après avoir reçu une exception ThreadAbortException suite à l'appel de la méthode Thread.Abort(). Si le thread se termine sans réinitialisation, l'état du thread qui a reçu la demande de terminaison passe de AbortRequested à Aborted.

Si vous souhaitez attendre la fin du thread, vous pouvez appeler la méthode Thread.Join(), qui arrêtera le thread en cours et le mettra à l'état WaitSleepJoin jusqu'à ce que le thread rejoint soit terminé.

Voir :

[]

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!