How to Build Multi-threaded Applications in .NET

Mazen S. AlzogbiTechnology SpecialistMicrosoft Corporation

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

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 300Level 300

Agenda

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

Multi-threading in .NETWhy use threads?

PerformancePerformance

PerceivedPerceivedperformanceperformance

Simplify codingSimplify coding

Multi-threading in .NETWhen 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

Multi-threading in .NETThreading 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

Multi-threading in .NETThreading 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

Multi-threading in .NET.NET Simplifies Threading Choices

Common access from all language variants

using System.Threading;using System.Threading;......ThreadStart ts = new ThreadStart(myMethod);ThreadStart ts = new ThreadStart(myMethod);Thread p1 = new Thread(ts);Thread p1 = new Thread(ts);p1.Name = "MyThread";p1.Name = "MyThread";P1.Start();P1.Start();

public void myMethod()public void myMethod(){{

// Do some work// Do some work......

}}

Multi-threading in .NETUsing 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

Multi-threading in .NETSimple Sample Application in C#

CompletedCompletedqueuequeue

WorkWorkqueuequeue

ProducerProducerobject andobject and

threadthread

ConsumerConsumerobject andobject and

threadthread

Work unitsWork unitsare arrays ofare arrays of

integersintegers

CompletedCompletedqueue holds queue holds sorted worksorted work

unitsunits

Demonstration 1Multi-threaded application

in C#

Tour of ApplicationRunning the Application

Agenda

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

SynchronizationFrom 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

SynchronizationManaging 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

SynchronizationUsing a lock Block

Example: lock block in C#

lock (this)lock (this){{ workQueue[nextFreeElement] = unit;workQueue[nextFreeElement] = unit; nextFreeElement++;nextFreeElement++;}}

Object whose lock is obtainedObject whose lock is obtained

CriticalCriticalcodecode

Lock released at end of blockLock released at end of block

}}

SyncLockSyncLockIn VB.NETIn VB.NET

Demonstration 2Adding Synchronization

Adding Basic Synchronization

SynchronizationObtaining Locks with Monitors

Example: Monitor usage in C#

Monitor.Enter(this);Monitor.Enter(this);

workQueue[nextFreeElement] = unit;workQueue[nextFreeElement] = unit;nextFreeElement++;nextFreeElement++;

Monitor.Exit(this);Monitor.Exit(this);

CriticalCriticalcodecode}}

Must remember to explicitly release the lockMust remember to explicitly release the lock

Demonstration 3Using Monitors

Using Monitors

SynchronizationChoosing a Synchronization Method

Things to consider Complexity Ability to split locks Specialized mechanisms, e.g. ReaderWriterLock

Agenda

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

Pools

Inter-thread CommunicationWhen 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

Inter-thread CommunicationThread lifecycle

Waiting and ready queues States

UnstartedUnstarted AbortedAborted

RunningRunning SuspendedSuspended

WaitSleepJoinWaitSleepJoin

Inter-thread CommunicationSimple 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()?

Inter-thread CommunicationNotification Alternatives

Pausing/sleeping Events (incl. ManualResetEvent) Timers (server and windows) Interlocked increment and decrement

Inter-thread Communication

Wait/Pulse in Sample Application

WorkWorkqueuequeue

ProducerProducerobject andobject and

threadthread

ConsumerConsumerobject andobject and

threadthread

Add workAdd workunitunit

Queue fullQueue full- Wait- Wait

RemoveRemovework unitwork unit

PulsePulse

Carry onCarry on

Add workAdd workunitunit

Demonstration 4Notification Between

Threads

Waiting for an Event

Inter-thread CommunicationManipulating other threads

Finding threads Thread information

ThreadState IsAlive

Joining another thread Thread.Join()

Inter-thread CommunicationTerminating 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

Agenda

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

Pools

Thread PoolsWhat 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

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

Thread PoolsQueuing 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

Thread PoolsCoding 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

Thread PoolsDelaying execution

Timed execution of delegates Useful for timer events etc. Use RegisterWaitForSingleObject

Thread PoolsSample Application with thread pool

Consumer

Thread poolThread pool

Producer

QueueQueuework itemwork item

Assign threadAssign threadto delegateto delegate

Demonstration 5Using a Thread Pool

Changing the Consumer Changing the ProducerEvaluating the Changes

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

Thank You!