1. How to Build Multi- threaded Applications in.NET Mazen S. Alzogbi Technology Specialist Microsoft Corporation

2. What we will cover The purpose of building multi-threading applications When multi-threading should be used, the pros and cons for multi-threaded applications The various multi-threading implementations, the pros and cons for each. How.NET simplifies building multi-threaded applications

3. Session Prerequisites Component-Based or Object-Oriented Development At least one of: Microsoft ® C# VB.NET Visual C++ ® Overview knowledge of the.NET Framework MTS, COM, DCOM, COM+ Level 300

4. Agenda Multi-threading in.NET Synchronization Inter-thread communication Improving Performance with Thread Pools

5. Multi-threading in.NET Why use threads? Performance Perceivedperformance Simplify coding

6. Multi-threading in.NET When Should You Use Threads? Take advantage of multi-processor systems for intensive computation Separate threads for different tasks Keeping the user interface "live" Waiting for I/O Split out complex test conditions and loops Creating servers Local and network

7. Multi-threading in.NET Threading Issues If threads are so good, why not use them everywhere? Contention for shared resources Need to co-operate to avoid corruption Writing is more of a problem than reading

8. Multi-threading in.NET Threading on the Windows ® Platform Win32 threads available from C/C++ COM threads and apartments Single Threaded Apartment (STA) Developer does not worry about threads Limitation on performance Multi-Threaded Apartment (MTA) Create thread-aware components Marshal interface pointers across apartments

9. Multi-threading in.NET.NET Simplifies Threading Choices Common access from all language variants using System.Threading;... ThreadStart ts = new ThreadStart(myMethod); Thread p1 = new Thread(ts); p1.Name = "MyThread"; P1.Start(); public void myMethod() { // Do some work...}

10. Multi-threading in.NET Using Threads Threads started by application Pass in parameters as properties on target object Threads stop when method is exited Thread object cannot be re-used Can stop thread with Abort method Distinguish between thread and object

11. Multi-threading in.NET Simple Sample Application in C# Completedqueue Workqueue Producer object and thread Consumer thread Work units are arrays of integers Completed queue holds sorted work units

12. Demonstration 1 Multi-threaded application in C# Tour of Application Running the Application

13. Agenda Multi-threading in.NET Synchronization Inter-thread communication Improving Performance with Thread Pools

14. Synchronization From STA to MTA Developer must consider threading issues Multiple threads contend for resources Instance variables Database connections GUI controls Writing is more of a problem than reading Identify critical regions that access resources Some more critical than others

15. Synchronization Managing Contention Protect critical regions with synchronization Objects have a lock that can be obtained Only one thread can own the lock at one time Other threads can block and wait… … or test the lock and take alternative action Very important to release locks Deadlock and "liveness problems" can ensue

16. Synchronization Using a lock Block Example: lock block in C# lock (this) { workQueue[nextFreeElement] = unit; workQueue[nextFreeElement] = unit; nextFreeElement++; nextFreeElement++;} Object whose lock is obtained Critical code Lock released at end of block } SyncLock In VB.NET

17. Demonstration 2 Adding Synchronization Adding Basic Synchronization

18. Synchronization Obtaining Locks with Monitors Example: Monitor usage in C# Monitor.Enter(this); workQueue[nextFreeElement] = unit; nextFreeElement++;Monitor.Exit(this); Critical code } Must remember to explicitly release the lock

19. Demonstration 3 Using Monitors Using Monitors

20. Synchronization Choosing a Synchronization Method Things to consider Complexity Ability to split locks Specialized mechanisms, e.g. ReaderWriterLock

21. Agenda Multi-threading in.NET Synchronization Inter-thread Communication Improving Performance with Thread Pools

22. Inter-thread Communication When Threads Need to Talk Waiting for a shared resource to become free Notification of the arrival of some work Producer and consumer model Waiting for clients Network server model Generally important application events For example: A long-running task has finished

23. Inter-thread Communication Thread lifecycle Waiting and ready queues States Unstarted Aborted Running Suspended WaitSleepJoin

24. Inter-thread Communication Simple communication with Wait/Pulse Monitor.Wait() Supply object to wait on Enter WaitSleepJoin Timed waits Monitor.Pulse() and Monitor.PulseAll() Choice between them Can only call them when you have the lock Wait() call gives up the lock until it resumes What happens when Pulse() is called before Wait()?

25. Inter-thread Communication Notification Alternatives Pausing/sleeping Events (incl. ManualResetEvent) Timers (server and windows) Interlocked increment and decrement

26. Inter-thread Communication Wait/Pulse in Sample Application Workqueue Producer object and thread Consumer thread Add work unit Queue full - Wait Remove work unit Pulse Carry on Add work unit

27. Demonstration 4 Notification Between Threads Waiting for an Event

28. Inter-thread Communication Manipulating other threads Finding threads Thread information ThreadState IsAlive Joining another thread Thread.Join()

29. Inter-thread Communication Terminating threads Stopping a thread Interrupt + InterruptedException Abort Abort and inconsistent state As locks are released, who will clean up objects? Alternative approaches using flags Use join() to check if thread has exited yet

30. Agenda Multi-threading in.NET Synchronization Inter-thread communication Improving Performance with Thread Pools

31. Thread Pools What are thread pools? Set of "worker" threads Thread controller assigns them to tasks Submit task to thread controller Number of threads in pool can grow or shrink Thread controller can use common metrics Developer does not have to worry about starting and terminating threads Useful for optimizing thread usage where there are many clients or units of work

32. Thread Pools.NET thread pools One thread pool per-process Pool is created when first work item is added Developer has no control over number of threads created Do NOT Abort pooled threads

33. Thread Pools Queuing work items ThreadPool class QueueUserWorkItem static method Work item consists of Method to run is defined by WaitCallback delegate (public void (object state)) State to be passed as object Still pass other state by setting variables on the method's object

34. Thread Pools Coding to work with thread pools Still need all synchronization as before Detection of when job is finished Events work well in this environment Use a.NET Event Define a callback method Register with event producer Event producer then notifies all listeners

35. Thread Pools Delaying execution Timed execution of delegates Useful for timer events etc. Use RegisterWaitForSingleObject

36. Thread Pools Sample Application with thread pool Consumer Thread pool Producer Queue work item Assign thread to delegate

37. Demonstration 5 Using a Thread Pool Changing the Consumer Changing the Producer Evaluating the Changes

38. Session Summary.NET has powerful, cross-language threading capabilities.NET makes it easy to use multiple threads Comprehensive library of classes and delegates Benefits of multi-threading include Simpler code Faster execution Improved user perception of performance Developer must think more about thread interaction

39. Thank You!