Seminar aus Softwareentwicklung Threading unter.NET Daniel Grünberger 9855066.

Seminar aus Softwareentwicklung

Threading unter .NET

Daniel Grünberger 9855066

Inhalt 2

Inhalt

Geschichtlicher Hintergrund

Überblick über Threads

Synchronisation von Daten

AppDomain

Literatur

Geschichtlicher Hintergrund 3

Geschichtlicher Hintergrund

Anfang der Softwareentwicklung verwendeten die meisten Programme „nur einen“ Prozess

Software-Programme wurden immer komplexer und umfangreicher– Verwendung von mehreren Prozessen

Probleme: welcher Prozess bekommt wie viel CPU-Leistung? Welcher Prozess bekommt welche Ressourcen? Viel Aufwand für Prozess-Kommunikation und nicht wirklich

effizient Lösung:

Man erschuf einen leichtgewichtigen Prozess Entstehung der Threads

Überblick über Threads 4

Überblick über Threads

Was ist ein Thread?

Erstellen eines Threads

Übergabe von Daten an Threads

Was ist ein Thread 5

Was ist ein Thread

Ein Thread:bezeichnet eine selbständig ausführbare

Programm-Funktion kann unabhängig vom übrigen Programm

ausgeführt werdenkann so dutzende von Teilaufgaben scheinbar

gleichzeitig ausführen

Was ist ein Thread 6

Verwendung

Falls Programm mehrere Dinge gleichzeitig machen soll, setzt man Threads ein

Beispiel: Berechnung der Zahl PI (3,14159265…) bis auf die

Millionste Stelle genau Ohne Thread: Programm läuft ein paar Millionen

Jahre ohne Output Mit Thread: Programm kann jederzeit unterbrochen

werden

Erstellen eines Thread 7

Erstellen eines Thread

Klassen/Funktionen für Threads sind im Namensraum System.Threading zu finden

z.B.:Start()Join()Sleep()Abort() ...


Zustandsdiagramm


Erstellen eines Thread

Beispiel: using System;using System.Threading;namespace ThreadHelloWorld{ class ThreadHelloWorldTest { static void ThreadEntry() { Console.WriteLine(“Hello Threading World”); } static void Main(string[] args) { Thread t = new Thread (new ThreadStart(ThreadEntry)); t.Name = “Hello World Thread”; t.Priority = ThreadPriority.AboveNormal; t.Start(); t.Join(); } }}

Neue Instanz + festlegen des Startpunktes

Optional: Name des Thread + Priorität

Starten des Thread + Warten bis beendet

Startpunkt: Funktion vom Typ void!

Übergabe von Daten an Threads 10

Übergabe von Daten an Threads

3 Möglichkeiten Daten zu übergeben:Verwendung von globalen VariablenKapselung des „Entrypoints“ in eine eigene

KlasseVerwendung von „thread local storage“ (TLS)


Verwendung von globalen Variablen

using System;using System.Threading;namespace ThreadHelloWorldStaticInformation{ class ThreadHelloWorldTest { static string message; static void ThreadEntry() { Console.WriteLine(message); } static void Main(string[] args) { message = “Hello World”; Thread t = new Thread (new ThreadStart(ThreadEntry)); t.Start(); t.Join(); } }}

Wert der globalen Variable zuweisen

Thread gibt Wert der globalen Variable aus


Kapselung des „Entrypoints“ in eigene Klasse

using System;using System.Threading;namespace ThreadHelloWorld { class HelloWorld { private string message; public string Message { get{ return message;} set{ message = value;} } public void ThreadEntry() { Console.WriteLine(message); } } class DynamicThreadInformation { static void Main(string[] args) { HelloWorld first = new HelloWorld(); first.Message = “Hello World”; Thread t = new Thread (new ThreadStart(first.ThreadEntry)); t.Start(); t.Join(); } }}

Eigene Klasse: Daten werden einem Property

zugewiesen

Instanz erstellen, Daten zuweisen und Thread starten


Verwendung von „thread local storage“ (TLS)

using System;using System.Threading;namespace ThreadHelloWorld{ class ThreadLocalStorage { static LocalDataStoreSlot slot; static void ThreadEntry() { Console.WriteLine(“The data in the slot is: {0}”, (string)Thread.GetData(slot)); } static void Main(string[] args) { String message = “Hello World”; slot = Thread.AllocateDataSlot(); Thread.SetData(slot,message); Thread t = new Thread (new ThreadStart(ThreadEntry)); t.Start(); t.Join(); } }}

Daten werden in TLS gestellt

Daten werden von TLS ausgelsen

Synchronisation von Daten 14

Synchronisation von Daten

Relativ einfache Datenübergabe an Threads

Jedoch Problem bei Multithreading – falls mehrere Threads auf gleiche Daten / Ressourcen zugreifen wollen


Multithreading - Beispiel 1(1/2) class Worker { private int Fib(int x) { return ((x<=1)?1:(Fib(x-1)+Fib(x-2))); } public void doWork() { string item = Convert.ToString(Thread.CurrentThread.Name) + “ “; for (int i =0; i < 10; i++) { Console.WriteLine(“Thread {0} {1} {2}”, item,i,Fib(30)); } } }

Entrypoint für Thread


Multithreading - Beispiel 1(2/2)

class UnsynchronizedTest { static void Main(string[] args) { Worker wq = new Worker(); Thread a = new Thread( new ThreadStart(wq.doWork)); a.Name = “a”; Thread b = new Thread( new ThreadStart(wq.doWork)); b.Name = “b”; Thread c = new Thread( new ThreadStart(wq.doWork)); c.Name = “c”; Thread d = new Thread( new ThreadStart(wq.doWork)); d.Name = “d”; Thread e = new Thread( new ThreadStart(wq.doWork)); e.Name = “e”; a.Start(); b.Start(); c.Start(); d.Start(); e.Start(); } }

Threads werden nicht synchronisiert gestartet


Ergebnis?

Nicht Zufriedenstellend!!


Warum?

Jeder Thread versucht CPU-Leistung zu bekommen

Kein geordnetes vorgehen

Im schlimmsten Fall kann es Threads geben, die niemals CPU-Leistung bekommen


Allgemeine Synchronisationsprobleme Race-Condition:

zeitlich unkoordinierte Arbeit zweier Threads gefährden den erfolgreichen Ablauf eines Programms

Deadlock: Bei einem Deadlock warten zwei oder mehrere

Threads aufeinander, und keiner kann sich aus dieser Situation befreien

Bsp: Dining Philosphers,…

© 2003 Daniel Grünberger 9855066 20

Race-Condition

public void ThreadProcA(int index){ lock(GlobalList) { GlobalList.Items.RemoveAt(index); }}public void ThreadProcB(){ For (int x =0; x < GlobalList.Items.Count; x++) { //… mehrere zeitaufwändige Operationen lock(GlobalList) { GlobalList.Items[x] = … // irgendeine Manipulation } }}

Es kann vorkommen, dass auf leere Listenelemente zugegriffen wird - FEHLER

Löschen eines Listenelements

Datenmanipulation: z.B.: Ausgabe


Deadlock

public void ThreadProcA(){ lock(RefA) { //… lock(RefB) { //… } }}public void ThreadProcB(){ lock(RefB) { //… lock(RefA) { //… } }}

Resource A wird gesperrt

Resource B wird gesperrt

Wartet vergeblich auf Ressource B

Wartet vergeblich auf Ressource A


Gegenmaßnahmen

Funktion Monitor bzw. Lock verwenden

Verhindert, dass mehrere Threads gleichzeitig auf die gleiche Ressource zugreifen

Man kann Ressourcen für Threads sperren und wieder freigeben


Funktion Monitor – Lock

Monitor.Enter(this) // kritische AusführungMonitor.Exit(this);Bzw.try{ Monitor.Enter(this); // kritische Ausführung}Finally{ Monitor.Exit(this)}

entspricht:lock(this){ //kritische Ausführung

}


Multithreading - Beispiel 2 public void doWork() { Monitor.Enter(this); string item = Convert.ToString(Thread.CurrentThread.Name) + “ “; for (int i =0; i < 10; i++) { Console.WriteLine(“Thread {0} {1} {2}”, item,i,Fib(30)); } Monitor.Exit(this); }


Ergebnis

Liefert das gewünschte Ergebnis

Was ist ein AppDomain 27

Was ist ein AppDomain

Ein AppDomains kann als eine Art Prozess gesehen werden, mit dem kleinen Unterschied, das dieser weniger Ressourcen verbraucht

Machen Applikation sicherer und vielseitiger

Werden auch als „leichtgewichtiger“ Prozess bezeichnet



Jede Applikation besitzt einen Standard-AppDomain und kommt auch damit aus

Applikation kann aber beliebig viele AppDomains verwalten

Verwendung: bei Verwendung von Bibliotheken die „nicht sicheren

Code“ beinhalten -> in AppDomain kapseln Plug-Ins im Internet-Explorer …


Unterschiede zwischen AppDomain und einem Thread AppDomain existiert für die Dauer der

Applikation ein Thread hingegen existiert nur für eine

bestimmte Zeit innerhalb eines AppDomains

Funktionsweise 31

Funktionsweise

AppDomain kann mittels der Methode CreateDomain() erzeugt werden

Beispiel:…AppDomain aDomain = AppDomain.CreateDomain(“My Domain”);…ObjectHandle objHandle = aDomain.CreateInstance( “ProgCSharp”, // der Assembly Name “ProgCSharp.Shape”, // Typ-Name mit Namensraum False, // Groß-Kleinschreibung ign. System.Reflection.BindingFlags.CreateInstance, null, // Binder new object[] {3,5}, // Argumente null, // Culture null, // Aktivierungsattribute null // Sicherheitsattribure);…

Funktionsweise 32

Funktionsweise

using System;

public class MyApp {

public static int main(string[] argv) { // create Domain AppDomain child = AppDomain.CreateDomain(“childapp”); // execute int r = child.ExecuteAssembly(“yourapp.exe”,null,argv); //unload domain AppDomain.Unload(child); // return result Return r; }}

Literatur 33

Literatur

Don Box, Chris Sells: Essential .NET, The Common Language Runtime, Addison-Wesley 2003

Kevin Burton: .NET Common Language Runtime Unleashed, Sams Publishing 2002

Dave Stutz, Ted Neward, Geoff Shilling: Shared Source CLI Essentials. O’Reilly 2003

Jesse Liberty: Programming C# 2nd Edition, O’Reilly & Associates Inc. 2002

Seminar aus Softwareentwicklung Threading unter.NET Daniel Grünberger 9855066.

Documents

Transcript of Seminar aus Softwareentwicklung Threading unter.NET Daniel Grünberger 9855066.