C# Multithreading Beheersen: Prestaties en Efficiëntie Verhogen

Threads zijn lichtgewicht processen. Een veelvoorkomend voorbeeld van thread-gebruik is de implementatie van concurrent programmeren door moderne besturingssystemen. Gebruik van threads bespaart CPU-cycli en verhoogt de efficiëntie van een applicatie.

Tot nu toe schreven we programma's waar een enkele thread draait als een enkel proces (de draaiende instantie van de applicatie). Op die manier kan de applicatie maar één taak tegelijk uitvoeren. Om meer dan één taak tegelijk uit te voeren, kan het worden opgedeeld in kleinere threads.

Thread Levenscyclus

De levenscyclus van een thread begint wanneer een object van de System.Threading.Thread klasse wordt aangemaakt en eindigt wanneer de thread wordt beëindigd of de uitvoering voltooid is.

De verschillende staten in de levenscyclus van een thread:

• Unstarted State – De thread-instantie is aangemaakt maar de Start-methode is nog niet aangeroepen.

• Ready State – De thread is klaar om te draaien en wacht op een CPU-cyclus.

• Not Runnable State – Een thread is niet uitvoerbaar wanneer:

  • Sleep-methode is aangeroepen
  • Wait-methode is aangeroepen
  • Geblokkeerd door I/O-operaties

• Dead State – De thread heeft de uitvoering voltooid of is afgebroken.

De Main Thread

In C# wordt de System.Threading.Thread klasse gebruikt voor het werken met threads. Hiermee kun je individuele threads in een multithreaded applicatie aanmaken en benaderen. De eerste thread die in een proces wordt uitgevoerd, heet de main thread.

Wanneer een C# programma start, wordt de main thread automatisch aangemaakt. Threads die met de Thread klasse worden aangemaakt, heeten de child threads van de main thread. Je kunt een thread benaderen via de CurrentThread eigenschap van de Thread klasse.

Het volgende programma demonstreert main thread uitvoering:

using System;
using System.Threading;
namespace MultithreadingApplication {
    class MainThreadProgram {
        static void Main(string[] args) {
            Thread th = Thread.CurrentThread;
            th.Name = "MainThread";
            Console.WriteLine("Dit is {0}", th.Name);
            Console.ReadKey();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

Dit is MainThread

Eigenschappen en Methodes van de Thread Klasse

De volgende tabel toont de meest gebruikte eigenschappen van de Thread klasse:

De volgende tabel toont de meest gebruikte methodes van de Thread klasse:

Threads Aanmaken

Threads worden aangemaakt door de Thread klasse uit te breiden. De uitgebreide Thread klasse roept vervolgens de Start() methode aan om de child thread uitvoering te beginnen.

Het volgende programma demonstreert het concept:

using System;
using System.Threading;
namespace MultithreadingApplication {
    class ThreadCreationProgram {
        public static void CallToChildThread() {
            Console.WriteLine("Child thread start");
        }
        static void Main(string[] args) {
            ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Child thread aanmaken");
            Thread childThread = new Thread(childref);
            childThread.Start();
            Console.ReadKey();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

In Main: Child thread aanmaken
Child thread start

Threads Beheren

De Thread klasse biedt diverse methodes voor het beheren van threads.

Het volgende voorbeeld demonstreert het gebruik van de Sleep() methode om een thread voor een bepaalde tijd te pauzeren:

using System;
using System.Threading;
namespace MultithreadingApplication {
    class ThreadCreationProgram {
        public static void CallToChildThread() {
            Console.WriteLine("Child thread start");
            // Thread pauzeren voor 5000 milliseconden
            int sleepfor = 5000;
            Console.WriteLine("Child Thread Gepauzeerd voor {0} seconden", sleepfor / 1000);
            Thread.Sleep(sleepfor);
            Console.WriteLine("Child thread hervat");
        }
        static void Main(string[] args) {
            ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Child thread aanmaken");
            Thread childThread = new Thread(childref);
            childThread.Start();
            Console.ReadKey();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

In Main: Child thread aanmaken
Child thread start
Child Thread Gepauzeerd voor 5 seconden
Child thread hervat

Threads Vernietigen

De Abort() methode wordt gebruikt om threads te vernietigen.

De runtime breekt de thread af door een ThreadAbortException te gooien. Deze exception kan niet gevangen worden; de controle gaat naar de finally block, indien aanwezig.

Het volgende programma illustreert dit:

using System;
using System.Threading;
namespace MultithreadingApplication {
    class ThreadCreationProgram {
        public static void CallToChildThread() {
            try {
                Console.WriteLine("Child thread start");
                // Werk doen, zoals tellen tot 10
                for (int counter = 0; counter <= 10; counter++) {
                    Thread.Sleep(500);
                    Console.WriteLine(counter);
                }
                Console.WriteLine("Child Thread Voltooid");
            } catch (ThreadAbortException e) {
                Console.WriteLine("Thread Abort Exception");
            } finally {
                Console.WriteLine("Kon de Thread Exception niet vangen");
            }
        }
        static void Main(string[] args) {
            ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Child thread aanmaken");
            Thread childThread = new Thread(childref);
            childThread.Start();
            // Main thread pauzeren
            Thread.Sleep(2000);
            // Nu child thread afbreken
            Console.WriteLine("In Main: Child thread afbreken");
            childThread.Abort();
            Console.ReadKey();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

In Main: Child thread aanmaken
Child thread start
0
1
2
In Main: Child thread afbreken
Thread Abort Exception
Kon de Thread Exception niet vangen