Your SlideShare is downloading. ×
0
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

C# Workshop - Threading

4,576

Published on

That's the slides for our C# Workshop at Darmstadt University of Technology, powered by Microsoft Student Partners.

That's the slides for our C# Workshop at Darmstadt University of Technology, powered by Microsoft Student Partners.

Published in: Technology
1 Comment
2 Likes
Statistics
Notes
  • Unglaublich guter workshop.
    Es gibt hilfreiche Code Beispiele, die einzelnen Folien sind sehr informativ und nicht überladen. Informativ auch wenn man schon einiges über Threads weiß.
    S.
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
No Downloads
Views
Total Views
4,576
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
78
Comments
1
Likes
2
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Threading C# Workshop, TU Darmstadt 2008, Präsentation von Qiong Wu (Microsoft Junior Student Partner)
  • 2.  Prozesse / Threads?  Arbeiten mit Threads  Erstellen von Threads  Threads beenden  Datenzugriff mit Threads  Deadlocks  ThreadPools  Asnychrone Programmierung  Timer  Windows Forms & Threading
  • 3.  Ablaufende Programme  Heißen unter Windows auch Tasks  Erlauben einem Prozessor mehrere Aufgaben „gleichzeitig“ zu bearbeiten  Interprozesskommunikation  Besitzen  Virtuellen Adressspeicher  Ausführbaren Code  Mindestens einen Ausführungsthread
  • 4.  Teilbereiche eines Prozesses  Erlauben einem Prozess mehrere Aufgaben „gleichzeitig“ zu bearbeiten.  Teilen sich virtuellen Adressspeicher und die Systemressourcen des Prozesses zu dem sie gehören  C# Programme starten automatisch Hauptthread
  • 5.  Beides Konzepte zur parallelen Programmierung  Prozesse sind unabhängige Ausführungseinheiten  Threads als logische Arbeitsteile eines Prozesses  Parallelisierung sowohl mit mehreren Prozessen als auch mehreren Threads theoretisch möglich
  • 6.  Parallelisieren von Programmaufgaben  Nutzen von Multi-Threaded Hardware (Multicore, Multiprozessor)  Trennung von Benutzeroberfläche und Berechnung  Verteilte Systeme
  • 7.  Threads können die Performance beeinträchtigen (Thread Overhead)  Threads sind häufige Fehlerquellen  Viele Threads bedeuten auch viel Ärger  Ergo: Threading nur dann einsetzen wenn es sinnvoll ist!
  • 8.  Multithreading in C# relativ einfach  Unterstützt asynchrones und synchrones Threading  Wichtigstes Werkzeug: System.Threading Namespace
  • 9.  Manuelles Erstellen von Threads  Beenden von Threads  Datenzugriffe koordinieren  Asynchrone Programmierung  ThreadPool verwenden
  • 10. 1. Methode für Threadeinstiegspunkt erstellen 2. ParametrizedThreadStart / ThreadStart Delegaten mit Verweis auf die Einstiegsmethode erstellen 3. Thread Objekt mit Delegaten erstellen 4. Optional: Threadeigenschaften festlegen 5. Thread starten
  • 11.  ThreadStart  für parameterlose Threadmethoden  ParametrizedThreadStart  für Threadmethoden mit Parameter  Parameter muss vom Typ object sein
  • 12. Auszuführende Methode static void Main(string[] args) { ThreadStart TestThreadStart = new ThreadStart(ThreadMethod); Thread TestThread = new Thread(TestThreadStart); TestThread.Name = quot;Test Threadquot;; TestThread.Priority = ThreadPriority.Normal; TestThread.IsBackground = false; TestThread.Start(); Threadoptionen Console.ReadLine(); } Kein Rückgabewert static void ThreadMethod() { Console.WriteLine(quot;Thread Runquot;); }
  • 13. Auszuführende Methode static void Main(string[] args) { ParameterizedThreadStart TestThreadStart = new ParameterizedThreadStart(ThreadMethod); Thread TestThread = new Thread(TestThreadStart); TestThread.Name = quot;Test Threadquot;; TestThread.Priority = ThreadPriority.Normal; Threadoptionen TestThread.IsBackground = false; TestThread.Start(quot;Testquot;); Start mit Parameter Console.ReadLine(); } Kein Rückgabewert object Parameter static void ThreadMethod(object Parameter) { Console.WriteLine(quot;Thread Run with Parameter: quot; + Parameter.ToString()); }
  • 14.  Unterscheidung zwischen  Foreground Threads  Background Threads  Thread.Join()
  • 15. Thread ForegroundThread = new Thread(new ThreadStart(ThreadMethod)); ForegroundThread.Start(); Foreground Thread Verhindert Beenden der Applikation Thread BackgroundThread = new Thread(new ThreadStart(ThreadMethod)); BackgroundThread.IsBackground = true; BackgroundThread.Start(); Background Thread kann nach Beendigung aller Foreground Threads terminiert werden
  • 16. ThreadStart operation = new ThreadStart(ThreadMethod); Thread[] theThreads = new Thread[5]; for (int x = 0; x <= 4; ++x) { theThreads[x] = new Thread(operation); theThreads[x].Start(); } Thread starten foreach (Thread oneThread in theThreads) { Console.WriteLine(quot;Waiting for Thread to terminatequot;); oneThread.Join(); Console.WriteLine(quot;Thread terminatedquot;); } Auf Threadende warten
  • 17.  Bestimmt die Vorrangregelung bei der Ausführung eines Threads  Thread.Priority Eigenschaft  ThreadPriority Enum  Lowest  BelowNormal  Normal  AboveNormal  Highest
  • 18. Standardpriorität ist ThreadPriority.Normal Thread NormalPriorityThread = new Thread(new ThreadStart(ThreadMethod)); Thread HighPriorityThread = new Thread(new ThreadStart(ThreadMethod)); HighPriorityThread.Priority = ThreadPriority.Highest; NormalPriorityThread.Start(); HighPriorityThread.Start(); Setzen der Threadpriorität auf ThreadPriority.Highest
  • 19.  Thread.Abort()  Löst ThreadAbortException aus  Beendet Thread nach Auslösen der Exception  Sicheres Beenden von Threads  ThreadAbortException behandeln  Alternative: Abortvariable
  • 20. static void Main(string[] args) { Thread newThread = new Thread(new ThreadStart(ThreadMethod)); newThread.Start(); Thread.Sleep(1000); newThread.Abort(); Console.ReadLine(); } Thread beenden
  • 21. static void ThreadMethod() { try { for (int i = 0; i < 100; i++) { Console.WriteLine(quot;Thread - working.quot;); Thread.Sleep(100); } } ThreadAbortException catch (ThreadAbortException e) behandeln { Console.WriteLine(quot;Thread - caught ThreadAbortException - resetting.quot;); Console.WriteLine(quot;Exception message: {0}quot;, e.Message); } finally { Console.WriteLine(quot;Just one more message before I dropquot;); } }
  • 22.  Einige Programmieren raten von Thread.Abort ab  Gründe  Thread.Abort kann Thread an jeder Stelle abbrechen  Finally Statements können übergangen werden  Ressourcen können ungeschlossen bleiben  Ansatz: Abortvariable einführen und im Thread pollen
  • 23. static void TestManualAbort() { Thread newThread = new Thread(new ThreadStart(ManualAbortThreadMethod)); newThread.Start(); Thread.Sleep(1000); Abort = true; } static volatile bool Abort = false; static void ManualAbortThreadMethod() { while (true) { if (Abort == false) { Console.WriteLine(System.DateTime.Now.ToString()); } else { break; } } }
  • 24.  Probleme mit Thread.Abort() lassen sich auch ohne Abortvariable umgehen  Alternative Lösungen  Code auf ThreadAbortException anpassen  Constrained Execution Regions einsetzen (Fortgeschritten)
  • 25. Oder einfach Pause?
  • 26.  Vor Multithreading: Nur ein gleichzeitiger Zugriff auf Daten  Mit Multithreading: Möglichkeit des gleichzeitigen Zugriffs auf Daten von mehreren Threads  Was passiert wenn mehrere Threads gleichzeitig einen Datenbestand manipulieren?
  • 27.  Mehrere Threads können eine gemeinsame Variable manipulieren  Probleme beim Rückschreiben von Werten  Fehlerhafte Werte als Ergebnis
  • 28. Thread 1 Thread 2 X = X + 30 X = X + 15 Variable einlesen Variable einlesen X=0
  • 29. Thread 1 Thread 2 X=0 X=0 X=0
  • 30. Thread 1 Thread 2 X=30 X=0 X=0
  • 31. Thread 1 Thread 2 X=30 X=15 Variable schreiben X=0
  • 32. Thread 1 Thread 2 Beenden… X=15 Variable schreiben X = 30
  • 33. Thread 2 Beenden… X = 15
  • 34. X = 15
  • 35.  Interlocked Klasse  Synchronisierungssperren
  • 36.  Bietet atomare Operationen für Variablen  Nur für triviale Operationen an einer Variable (Addieren, Dekrementieren, Vertauschen, Inkrementieren)  Effektiv, aber beschränktes Einsatzgebiet
  • 37.  Monitor.Enter() + Monitor.Exit()  Lock Schlüsselwort  ReaderWriterLock  Mutex / Semaphore / AutoResetEvent / ManualResetEvent
  • 38.  Setzt in Codeabschnitt eine Synchronisierungssperre  Synchronisieren auf ein Objekt  Besitzer des Monitor des Objekts erhält exklusiven Zugriff auf Codeabschnitt  Andere blockieren bis Freigabe des Monitors
  • 39.  Synchronisierungsobjekt als Parameter  Umschließt Codebereich implizit mit Monitor.Enter() und Monitor.Exit()
  • 40. Sperrvariable public static object Lockvar = new object(); public static void LockMethod(object Parameter) { Monitor.Enter(Lockvar); try { Anfang count++; Synchronisierungssperre Console.WriteLine(quot;Thread quot; + count + quot; Writingquot;); finally { Monitor.Exit(Lockvar); } } Ende Synchronisierungssperre
  • 41. Sperrvariable public static object Lockvar = new object(); public static void LockMethod(object Parameter) { lock (Lockvar) Sperrvariable { count++; Console.WriteLine(quot;Thread quot; + count + quot; Writingquot;); } }
  • 42.  Zwei Threads schließen sich gegenseitig durch Synchronisationssperren aus  Thread A wartet auf Thread B, Thread B wartet auf Thread A  Endloses Warten
  • 43. public static object Lockvar1 = new object(); public static object Lockvar2 = new object(); public static void DeadLockMethodOne() { lock (Lockvar1) { Sperrvariable lock (Lockvar2) Sperrt Lockvar1 { Console.WriteLine(quot;Firstquot;); } } } public static void DeadLockMethodTwo() { lock (Lockvar2) { lock (Lockvar1) Sperrt Lockvar2 { Console.WriteLine(quot;Secondquot;); } } }
  • 44.  Sorgfältig Programmieren!  Monitor.TryEnter() mit Zeitlimit  Kurze Codeabschnitte sperren
  • 45.  ReaderWriteLock Klasse ermöglicht  Ausschließliche Lesesperre  Schreibsperre  Wechsel von Lese zu Schreibsperre und vice versa
  • 46. Oder noch eine Pause?
  • 47.  Erstellung eigener Threads oft unnötig  ThreadPool verwaltet Threads die auf Abruf bereit stehen, Standardanzahl 25  Overhead bei Threaderstellung und Threadvernichtung eliminiert  ThreadPool Threads sind Hintergrundthreads  ThreadPool Arbeitsaufgaben können nicht durch Fremdeinwirkung abgebrochen werden
  • 48.  ThreadPool.QueueUserWorkItem  Übergabe von Verweis auf Funktion  Optional: Übergabe von Parameter  ThreadPool.GetMaxThreads  Anzahl der maximal verfügbaren Threads abrufen  ThreadPool.SetMaxThreads  Anzahl der maximal verfügbaren Threads festlegen
  • 49. WaitCallback Delegate Thread mit Parameter starten WaitCallback workItem = new WaitCallback(ThreadMethod); if (!ThreadPool.QueueUserWorkItem(workItem, quot;ThreadPooledquot;)) { Console.WriteLine(quot;Element konnte nicht in Warteschlange gestellt werdenquot;); }
  • 50.  Idee: Asynchrones Starten & Beenden eines Ablaufs  Vorteile  Keine manuelle Verwaltung des Threads notwendig  Automatische Threadskalierung  Performancegewinn durch automatische Nutzung von ThreadPool  3 Verwendungsmodelle  Warten-bis-fertig Modell  Pollingmodell  Rückrufmodell
  • 51.  Asynchrone Operation starten  Andere Arbeiten erledigen  Mit EndXXX auf Ende der Operation warten
  • 52. Andere Arbeiten ausführen Console.WriteLine(quot;Start Async Fetchin..quot;); GenericMethodDelegate<int> method = IntFetcher.Fetch; IAsyncResult ar = method.BeginInvoke(null, method); Methode asynchron Thread.Sleep(1000); ausführen Console.WriteLine(quot;Got quot; + method.EndInvoke(ar)); Console.WriteLine(quot;End Async Fetchin..quot;); Auf Ende der Methode warten
  • 53.  Starten der asnychronen Operation  Regelmäßig überprüfen ob die Operation abgeschlossen ist  Nach Abgeschlossener Operation EndXXX aufrufen
  • 54. Andere Arbeiten ausführen Console.WriteLine(quot;Start Async Fetchin..quot;); IAsyncResult ar2 = method.BeginInvoke(null, method); Methode asynchron while (!ar2.IsCompleted) ausführen { Thread.Sleep(1000); } Regelmäßig pollen Console.WriteLine(quot;Got quot; + method.EndInvoke(ar2)); Console.WriteLine(quot;End Async Fetchin..quot;); Ergebnis abrufen (keine Wartezeit)
  • 55.  Starten der asynchronen Operation mit Übergabe einer Rückruffunktion
  • 56. Andere Arbeiten ausführen Callback Funktion angeben Console.WriteLine(quot;Start Async Fetchin..quot;); IAsyncResult ar3 = method.BeginInvoke(new AsyncCallback(CompleteFetch), method); Thread.Sleep(1000); static void CompleteFetch(IAsyncResult result) { GenericMethodDelegate<int> method = (GenericMethodDelegate<int>)result.AsyncState; int i = method.EndInvoke(result); Console.WriteLine(quot;Got quot; + i); Console.WriteLine(quot;End Async Fetchin...quot;); } Ergebnis abrufen (keine Wartezeit)
  • 57.  Try Catch bei Aufruf der EndXXX Methode anwenden try { Console.WriteLine(quot;Got quot; + method.EndInvoke(ar2)); } catch { Console.WriteLine(quot;Error occuredquot;); } finally { Console.WriteLine(quot;End Async Fetchin..quot;); }
  • 58.  Delegaten erstellen  BeginInvoke des Delegaten aufrufen  EndInvoke des Delegaten aufrufen
  • 59. Delegat auf auszuführende Methode public delegate TOutput GenericMethodDelegate<TOutput>(); Methode dem Delegat static void TestAsync() zuweisen { Console.WriteLine(quot;Start Async Fetchin..quot;); GenericMethodDelegate<int> method = IntFetcher.Fetch; IAsyncResult ar = method.BeginInvoke(null, method); Thread.Sleep(1000); Console.WriteLine(quot;Got quot; + method.EndInvoke(ar)); Console.WriteLine(quot;End Async Fetchin..quot;); } Blockieren bis asynchrone Methode asynchron starten Methode beendet
  • 60.  Ruft eine Methode asynchron nach Zeitspanne auf  Wiederholt Aufruf der Methode nach Zeitspanne  Timer.Change
  • 61. Tick Intervall TimerCallbackDelegate Startverzögerung static void TestTimer() { Timer tm = new Timer(new TimerCallback(ThreadMethod), quot;Timerquot;, 0, 1000); Thread.Sleep(1000); tm.Change(0, 100); } Parameter Intervall / Verzögerung ändern
  • 62.  Häufigster Anwendungsfall für Threading: Rechenlast aus GUIs auslagern  Dem Hauptthread möglichst wenig Rechenlast zuordnen  Rechenlast in Hauptthread verursacht hängende GUIs  Problematik: Zugriff auf Steuerelemente von Threads aus
  • 63. private void cmdThreaded_Click(object sender, EventArgs e) { Thread FormsThread = new Thread(new ThreadStart(DoWork)); FormsThread.Start(); } private void cmdUnthreaded_Click(object sender, EventArgs e) { DoWork(); }
  • 64. private void button1_Click(object sender, EventArgs e) { Thread FormsThread = new Thread(new ThreadStart(ManipulateList)); FormsThread.Start(); } private void ManipulateList() { listBox1.Items.Add(quot;testquot;); }
  • 65.  Direktes Manipulieren von Windows Forms Steuerelementen löst Exception aus  Mit Invoke den UI Thread auffordern Manipulationen vorzunehmen  Delegaten übergeben  Asynchroner Aufruf ebenfalls möglich  Optional: Eine Methode für Invoke und Direkt mit InvokeRequired Eigenschaft
  • 66. Delegat nach Funktion erstellen private delegate void ManipulateListDelegate(); private void ManipulateList() Invoke benötigt? { if (listBox1.InvokeRequired == true) { listBox1.Invoke(new ManipulateListDelegate(ManipulateList)); } Invoke aufrufen mit Verweis else auf Methode { listBox1.Items.Add(quot;testquot;); } } Manipulationen vornehmen

×