.net Threading Using C#

Front 1

What is the Thread class for

Back 1

1. Creates and controls a thread.
2. Sets its priority.
3. Gets its status."

Front 2

What is the ThreadPool class for

Back 2

To provide a recyclable pool of worker threads, managed by the system, that can be used to:

1. Execute tasks.
2. Post work items.
3. Process asynchronous I/O.
4. Wait on behalf of other threads.
5. Process timers.

Front 3

What is a ThreadStart delegate for

Back 3

Represents a parameterless method that is executed by a thread that is explicitly started (not a pool-thread). Note that the explicit instantiation of this delegate is not needed in the latest versions of C# (you can just put the name of the method, rather than "new ThreadStart(...)"

Front 4

What is a ParameterizedThreadStart delegate

Back 4

Represents the method that executes on a Thread that is explicitly started (not a pool-thread). It allows Thread.Start to accept an Object:

new Thread(Print).Start("Hello!");

void Print(object msgObj)
{
var msg = (string) msgObj; // cast needed (msg == "Hello!")
Console.WriteLine(msg);
}

//Note: this is simpler with a lambda expression:
new Thread(() => Console.Write("Hello!")).Start();

Front 5

What does the SynchronizationContext class do.

Back 5

Provides the basic functionality for propagating a synchronization context in various models (marshall code between threads). Here's how to "post" to a UI control from a worker thread:

var _uiSc = SynchronizationContext.Current; //static prop
new Thread(Work).Start();

void Work()
{
_uiSc.Post( _ => txtMessage.Text = message);
}

(useful, because this works for WPF, Metro & Windows Forms)

Front 6

What is the Timeout class

Back 6

Static class that contains constants used to specify an infinite amount of time, ie:

Thread.Sleep(Timeout.Infinite);
Thread.Sleep(Timeout.InfiniteTimeSpan); // for overload that expects a TimeSpan

Front 7

What is the Timer class, and how is it used.

Back 7

Uses a pooled thread to generates recurring events in an application:

var tmr = new Timer(Tick, "tick ...", 5000, 1000)
Console.ReadLine(); // to allow timer to work
tmr.Dispose(); // stops timer & cleans up

void Tick(object data)
{
Console.WriteLine(data); // writes "tick ... tick ..., etc"
}

Front 8

Explain the AutoResetEvent class, with a code snippet.

Back 8

A sealed class that lets ONE waiting thread "through" when "set" by another. Works "like" a ticket-turnstile: when Set is called by another thread (a "ticket" is supplied) the turnstile lets ONE thread through, and immediately closes again. Snippet:

var _aRE = new AutoResetEvent(false);
new Thread(Waiter).Start();
Thread.Sleep(1000); // pause for a sec
_aRE.Set(); // let one waiter through

void Waiter()
{
Console.WriteLine("Waiting ...");
_aRE.WaitOne(); // wait til this one lets you through
Console.WriteLine("Made it!);
}

//output
Waiting... <pause> Made it!

Front 9

What is a TimerCallback delegate

Back 9

It represents the method that handles calls from a Timer:

public delegate void TimerCallback(object state)

Front 10

What is the WaitCallback delegate (show code snippet of its use)

Back 10

Represents a callback method to be executed by a thread pool thread (not by one we start in code). The method is to be executed immediately if a thread is available:

ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadWork), "Hello");

void ThreadWork(object msg)
{
Console.WriteLine((string)msg);
}

Front 11

What is the WaitHandle class

Back 11

Abstract class that encapsulates operating system–specific objects to allow threads to wait for exclusive access to shared resources. Implemented by these classes:

1. EventWaitHandle
i) AutoResetEvent
ii) ManualResetEvent
2. Mutex
3. Semaphore

Front 12

What is a WaitOrTimerCallback delegate

Back 12

It represents a method to be called (on a "pool" thread) when a WaitHandle is signaled or times out.

Front 13

What is a ThreadExceptionEventArgs class

Back 13

Provides data for the ThreadException event.

Front 14

What is a ThreadExceptionEventHandler Delegate

Back 14

Represents the method that will handle the ThreadException event of an Application.

Front 15

What is the ThreadState enumeration class for, and how does it maintain data.

Back 15

Specifies the execution states of a Thread.

This enumeration has a ComVisibleAttribute attribute that allows a bitwise combination of its member values.

Front 16

What is the purpose of the ThreadPriority enumeration class.

What enumeration values does it contain?

Back 16

To specify the scheduling priority of a Thread.

enum ThreadPriority {Lowest, BelowNormal, Normal, AboveNormal, Highest}

Front 17

ReaderWriterLock class

Back 17

Defines a lock that supports single writers and multiple readers.

Front 18

Explain the ManualResetEvent class

Back 18

It's a sealed class that works as a simple gate: calling Set opens the gate allowing through ANY number of threads that are calling WaitOne.

Front 19

IAsyncResult interface

Back 19

Represents the status of an asynchronous operation.

Front 20

EventWaitHandle class

Back 20

Represents a thread synchronization event.

Front 21

What is the RegisteredWaitHandle class & what is used for. Write code snippet.

Back 21

This is a sealed class that represents a reference to a registration action (with the thread pool) that results by calling RegisterWaitForSingleObject to schedule a delegate execution upon an wait-handle signaling, or timeout.

AutoResetEvent ev = new AutoResetEvent(false);
RegisteredWaitHandle handle = ThreadPool.RegisterWaitForSingleObject(ev, WaitProc, "data", 1000, false);
...
ev.Set();

public void WaitProc(object data, bool timeOut)
{
// ... do something
}

Useful so a thread does not have to wait on a wait handle (i.e.: AutoResetEvent "ev" above) to be signaled. Instead, this attaches a "continuation" method (WaitProc) to be automatically executed when the handle is signaled/timeout.

Front 22

What is the SendOrPostCallback delegate

Back 22

It represents a method to be called when a message is to be dispatched (send/post) to another thread (usually the UI thread) using a synchronization context?

Here's how a working thread can reach back to the UI thread:

var uiSynchContext = SynchronizationContext.Current; // in UI thread

// .... later (in worker thread) note: UpdateUI is the delegate here
uiSychContext.Post(UpdateUI, "new msg");

void UpdateUI(object msg)
{
uiTextBox.Text = (string) msg;
}

Front 23

What is the function of the IOCompletionCallback delegate.

Back 23

To receive the error code, number of bytes, and overlapped value type when an I/O operation completes on the thread pool.

Front 24

Interlocked class

Back 24

Provides atomic operations for variables that are shared by multiple threads.

Front 25

What is the NativeOverlapped structure

Back 25

Provides an explicit layout that is visible from unmanaged code and that will have the same layout as the Win32 OVERLAPPED structure with additional reserved fields at the end.

Front 26

What is the Overlapped class

Back 26

Provides a managed representation of a Win32 OVERLAPPED structure, including methods to transfer information from an Overlapped instance to a NativeOverlapped structure.

Front 27

What is the ExecutionContext class

Back 27

A sealed class that manages the execution context for the current thread.

Front 28

What is the HostExecutionContext class

Back 28

Encapsulates and propagates the host execution context across threads.

Front 29

What does the HostExecutionContextManager class provide.

Back 29

Provides the functionality that allows a common language runtime host to participate in the flow, or migration, of the execution context.

Front 30

Explain the ContextCallback delegate

Back 30

Used by ExecutionContext.Run & SecurityContext.Run methods. It represents a method to be called within the new ExecutionContext. After the execution ends, the previous context is restored.

Signature: public delegate void ContextCallback(Object state)

Front 31

What is the LockCookie structure

Back 31

A value type that defines the lock that implements single-writer/multiple-reader semantics. It can be used to "upgrade" the lock from "reader lock" to "writer lock" and viceversa.

Front 32

What does the Monitor class provide.

Back 32

Provides a mechanism that synchronizes access to objects. Methods include Enter, Wait, Pulse, PulseAll, Exit.

Front 33

What is the Mutex class

Back 33

A synchronization primitive that can also be used for interprocess synchronization.

Front 34

Explain a difference between the Semaphore and the Monitor classes.

Back 34

The Semaphore class, unlike Monitor, can be used with WaitHandle.WaitAll and WaitAny, and can be passed across AppDomain boundaries.

Front 35

What is the ISynchronizeInvoke interface

Back 35

Provides a way to synchronously or asynchronously execute a delegate. Has these methods:

1. BeginInvoke (asynchronous begin)
2. EndInvoke (asynchronous end)
3. Invoke (synchronous/blocking)

& this property:
InvokeRequired (true if we're in another thread ... and thus require above methods, rather than directly updating, for instance, the UI element.

Front 36

What class is used to:

1. Create and controls a thread.
2. Sets its priority.
3. Gets its status.

Back 36

The Thread class

Front 37

What represents a parameterless method that executes on an explicitly started Thread (not from the pool)

Back 37

ThreadStart delegate

Front 38

What represents the method that executes on a (not thread-pool) Thread that allows Thread.Start to accept an Object.

Back 38

ParameterizedThreadStart delegate

Front 39

What class provides the basic functionality for propagating a synchronization context in various synchronization models.

Back 39

SynchronizationContext class

Front 40

What sealed class contains a constant used to specify an infinite amount of time.

Back 40

Timeout class

Front 41

What class is capable of generating recurring events in an application.

Back 41

The Timer class

Front 42

What class notifies a waiting thread that an event has occurred.

Back 42

AutoResetEvent class

Front 43

What represents the method that handles calls from a Timer.

Back 43

The TimerCallback delegate

Front 44

What represents the (thread-work) method called by the QueueUserWorkItem method of the ThreadPool class.

Back 44

WaitCallback delegate

Front 45

What class encapsulates operating system–specific objects that wait for exclusive access to shared resources.

Back 45

WaitHandle class

Front 46

What represents a method to be called in a "pool" thread when a WaitHandle is signaled or times out.

Back 46

WaitOrTimerCallback delegate

Front 47

What class provides data for the ThreadException event.

Back 47

The ThreadExceptionEventArgs class

Front 48

What represents the method that will handle the ThreadException event of an Application.

Back 48

ThreadExceptionEventHandler Delegate

Front 49

What enumeration class:

1. Specifies the execution states of a Thread.
2. Has a ComVisibleAttribute attribute that allows a bitwise combination of its member values.

Back 49

ThreadState enumeration

Front 50

What class is used to specify the scheduling priority of a Thread.

Back 50

ThreadPriority enumeration

Front 51

What class defines a lock that supports single writers and multiple readers.

Back 51

The ReaderWriterLock class

Front 52

What class notifies one, or more, waiting threads that an event has occurred & allows multiple threads to proceed.

Back 52

The ManualResetEvent class. It works as a simple "gate": ... when signaled, all threads that are blocking waiting for this event are "let through". It stays in this (unblocking) state until it is manually reset.

Front 53

What class represents the status of an asynchronous operation.

Back 53

The IAsyncResult interface

Front 54

What class represents a thread synchronization event.

Back 54

The EventWaitHandle class

Front 55

What class represents a handle that has been registered by calling RegisterWaitForSingleObject.

Back 55

RegisteredWaitHandle class

Front 56

What represents a method to be called when a message is to be dispatched (send/post) to another thread (usually the UI thread) using a synchronization context?

Back 56

The SendOrPostCallback delegate.

Here's how a working thread can reach back to the UI thread:

// in UI thread we "store" the UI context
var uiSynchContext = SynchronizationContext.Current;

// .... later (in worker thread) run delegate UpdateUI
uiSychContext.Post(UpdateUI, "new msg");

// this method will run in the UI context
void UpdateUI(object msg)
{
uiTextBox.Text = (string) msg;
}

Front 57

What represents a method to be called, when an I/O operation completes on a thread pool, and which receives the error code, number of bytes, and overlapped value type.

Back 57

IOCompletionCallback delegate

Front 58

What class provides atomic operations for variables that are shared by multiple threads.

Back 58

The "Interlocked" class. Example, for thread safety, use:

int count = 0;
Interlocked.Increment(ref count); // static method

... instead of just:
count++;

Increment: loads/increments/stores in one atomic operation. (other ops: Decrement, Exchange, Read, etc.)

Front 59

What structure provides an explicit layout that is visible from unmanaged code and that will have the same layout as the Win32 OVERLAPPED structure with additional reserved fields at the end.

Back 59

NativeOverlapped structure

Front 60

What Provides a managed representation of a Win32 OVERLAPPED structure, including methods to transfer information from an Overlapped instance to a NativeOverlapped structure.

Back 60

Overlapped class

Front 61

What sealed class manages the execution context for the current thread.

Back 61

ExecutionContext class

Front 62

What class encapsulates and propagates the host execution context across threads.

Back 62

HostExecutionContext class

Front 63

What class provides the functionality that allows a common language runtime host to participate in the flow, or migration, of the execution context.

Back 63

HostExecutionContextManager class

Front 64

What represents/stands-for the method to be called within a new context.

Back 64

ContextCallback delegate

Front 65

What value type defines the lock that implements single-writer/multiple-reader semantics.

Back 65

LockCookie structure. Use:

static int resource = 0;
var rwl = new ReaderWriterLock();
rwl.AcquireReaderLock(1000); // 1 sec timeout
...
Console.WriteLine("resource = {0}" + resource); // safe to read
...
// If needed upgrade to "writer" lock
LockCookie lc = rwl.UpgradeToWriterLock(1000);
resource = 123; // safe to change value
...
rwl.DowngradeFromWriterLock(ref lc);
Console.WriteLine("resource still = {0}", resource); // still safe to read
...
rwl.ReleaseReaderLock(); // ensure lock is released

Front 66

What class provides a mechanism that synchronizes access to objects, including: Enter, Wait, Pulse, PulseAll & Exit.

Back 66

Monitor class

Front 67

What class is another synchronization primitive that can also be used for interprocess synchronization.

Back 67

Mutex class

Front 68

What synchronization class, unlike Monitor, can be used with WaitHandle.WaitAll and WaitAny, and can be passed across AppDomain boundaries.

Back 68

Semaphore class

Front 69

What interface provides a way to synchronously or asynchronously execute a delegate. Show code snippet of invocation.

Back 69

The ISynchronizeInvoke interface provides these methods:

1. BeginInvoke (asynch begin)
2. EndInvoke ( asynch end )
3. Invoke (synchronous)
4. InvokeRequired (true if worker thread is different than one implementing this interface)

Example: snippet above (from codeproject.com) shows an event handler that updates a Windows form field. If worker thread is different (than UI thread) it will use Begin invoke, otherwise (if we're in the same UI thread) then the field is directly updated.

Front 70

What methods are used to delineate a section of code that cannot be safely aborted?

Back 70

Thread.BeginCriticalRegion();
... // do critical work here.
Thread.EndCriticalRegion(); // Both static

Front 71

What are the ThreadState Enumeration items?

Back 71

1. Running
2. Stopped
3. Stop Requested
4. Aborted
5. Abort Requested,
6. Background

Front 72

What Thread method is used to block the calling thread until the thread terminates.

Back 72

Join

Front 73

What are some Interlocked methods

Back 73

Add, Decrement, Exchange, Increment, Read

Front 74

What class does lock use?

Back 74

It uses the Monitor class. The "lock" statement is a shortcut for calling the "Enter" & "Exit" methods of the Monitor class.

Front 75

What are the monitor methods

Back 75

1. Wait
2. TryEnter,
3. Enter
4. Exit

Front 76

What class do Mutex, Semaphore, AutoRestEvent, and ManualRestEvetn all inherit from?

Back 76

WaitHandle class

Front 77

What is mutex short for?

Back 77

Mutual exclusion

Front 78

How long does the AutoResetEvent stay signaled once set.

Back 78

AutoResetEvent remains signaled until a single waiting thread is released, and then automatically returns to the non-signaled state.

If no threads are waiting, the state remains signaled indefinitely.

Front 79

How long does the ManualResetEvent stay signaled once set.

Back 79

Once it has been signaled, ManualResetEvent remains signaled until it is manually reset

Front 80

What are the three styles of programming with the APM?

Back 80

Wait-Until-Done, Polling, CallBack

Front 81

What class Provides a recyclable pool of worker threads, managed by the system, that can be used to:

1. Execute Tasks.
2. Post work items.
3. process asynchronous I/O.
4. Wait on behalf of other threads.
5. Process timers.

Back 81

The ThreadPool class

Front 82

Write a line of code to create a Task that executes a simple "Console.WriteLine(" ... ")"

Back 82

Task.Run(() => Console.WriteLine(" ... "));

Front 83

What does the [STAThread] attribute do?

Back 83

It indicates that the COM threading model for the application is "single-threaded apartment". This attribute must be present on the entry point of any application that uses Windows Forms because, although core Windows Forms does not use COM, many components of the OS such as system dialogs do use this technology.

Front 84

Does locking (using the lock statement) restrict access to the synchronization object?

For instance: if a thread calls lock(x) ... can another thread execute x++?

Back 84

Locking does NOT restrict access to the synchronization object itself. However, a restriction is that ONLY ONE thread can lock the synchronization object at a time. Any other attempting this would be queued.