Lecture for Binary Studio Academy (.NET group) by Max Goncharuk (.NET developer at Binary Studio) academy.binary-studio.com

1. Concurrency in C# 5.0
Binary Studio Academy
binary-studio.com

2. Contents
1. Concurrency
2. Multithreading Programming
3. Thread Synchronization
4. Parallel Programming
5. Collections
6. Asynchronous Programming
7. Cancellation
8. Async Synchronization

3. Concurrency

4. Asynchronous

5. Asynchronous
OK
First Name
Last Name
Birthdate
Program Storage

6. Asynchronous
OK
Salary
Percent
Program
Loop

7. Asynchronous
OK
Salary
Percent
Program
Loop

8. Multithreading Programming
Main thread
Thread_1 Thread_2 Thread_3
Thread_4 Thread_5 Thread_6
Thread_7
Thread_8 Thread_9

9. Thread
Program
Thread:
- Culture
- Principals
- Priority
- Execution Context

10. Demo

11. ThreadPool
Program
ThreadPool(10)
Thread1 Thread2

12. Demo

13. BackgroundWorker
- DoWork (ReportProgress())
- ProgressChanged
- RunWorkerCompleted

14. Demo

15. Timers
System.Threading.Timer:
- callback based
- need to dispose
System.Timers.Timer:
- event based
- thread safety
Timers in depth

16. Demo

17. Types Of Threads
● Main Thread (UI Thread)
○ Entry point
○ Sync
● Worker Thread
○ Independent flow
○ Async

18. Thread Synchronization

19. Thread Synchronization Primitives
● Lock
● Mutex
● AutoResetEvent
● Semaphore

20. Demo

21. Parallel Programming

22. Data Parallelism
1
2
3
4
5
6
7
Process:
y =x * x
1
4
9
16
25
36
49

23. Task Parallelism
1
2
3
4
5
6
7
Process:
Console.WriteLine(collection.Max())
Process:
Console.WriteLine(collection.Min())
Process:
Console.WriteLine(collection.Average())
Process:
Console.WriteLine(collection.Sum())
Task

24. PLINQ
collection.AsParallel()
.Where(c => c > 0)
.ForAll()
(from c in collection.AsParallel()
where c > 0
select c).ForAll()

25. Demo

26. Collections
Immutable Collections
Thread Safe collections
Blocking Collections
Asynchronous collections

27. Immutable Collections
● ImmutableStack<T>
● ImmutableQueue<T>
● ImmutableList<T>
● ImmutableSet<T>
● ImmutableDictionary<T, K>
var list = ImmutableList<int>.Empty;
list = list.Insert(0, 1);
list = list.Add(2);
list = list.RemoveAt(0);
Console.WriteLine(list[0]);

28. Thread Safe Collections
● ConcurrentStack<T>
● ConcurrentQueue<T>
● ConcurrentBag<T>
ConcurrentDictionary<int, string> dictionary =
new ConcurrentDictionary<int, string>();
dictionary.AddOrUpdate(
k,
key => value,
(key, oldvalue) => value); // if key exist

29. Blocking Collections
new BlockingCollection<T>(); // first-in-first-out
new BlockingCollection<T>(new ConcurrentStack<T>()); // last-in-last-out
new BlockingCollection<T>(new ConcurrentBag<T>()); // unordered
Thread1:
_bc.Add(1);
_bc.Add(2);
_blockingQueue.CompleteAdding();
Thread2:
foreach(var item in _bc.GetConsumingEnumerable())
Console.WriteLine(item);

30. Asynchronous Collections
BufferBlock<T>
AsyncProducerConsumerQueue<T>
AsyncCollection<T> Nito.AsyncEx

31. Demo

32. Asynchronous Programming
OK
First Name
Last Name
Birthdate
Program Storage

33. Asynchronous Programming Model (APM)
● BeginMethod
● Callback
● IAsyncResult
● IAsyncState
● EndMethod
FileStream fs = new FileStream(path, FileMode.OpenOrCreate,
FileAccess.Write, FileShare.None, 8,
FileOptions.Asynchronous);
string content = "A quick brown fox jumps over the lazy dog";
byte[] data = Encoding.Unicode.GetBytes(content);
fs.BeginWrite(data, 0, data.Length, OnWriteCompleted, fs);
private static void OnWriteCompleted(IAsyncResult asyncResult) {
FileStream fs = (FileStream)asyncResult.AsyncState;
fs.EndWrite(asyncResult);
fs.Close();
}

34. Event-based Asynchronous Pattern (EAP)
var wc = new WebClient();
wc.DownloadStringCompleted += (sender, args) =>
{
if (args.Cancelled)
Console.WriteLine ("Canceled");
else if (args.Error != null)
Console.WriteLine ("Exception: " +
args.Error.Message);
else
{
Console.WriteLine (args.Result.Length + " chars were
downloaded");
// We could update the UI from here...
}
};
wc.DownloadStringAsync (new Uri ("http://www.linqpad.net")); //
Start it
● Event
● EventArgs
● ObjectState

35. Task-based Asynchronous Pattern (TAP)
public Task<T> MethodNameAsync(…, CancellationToken cancellationToken, IProgress<T> progress);
● Task, Task<T>
● CancellationToken
● IProgress
● syntax support (async/await)

36. Create task
● new Task(() => return 42).Start()
● TaskFactory.Start(() => return 42)
● Task.Run(() => return 42)
public async Task Method()
{
await Task.Delay(500);
return Task.Run(() => Console.WriteLine(“Async”))
.ContinueWith((t) => Console.WriteLine(“Task finished”));
}

37. Task Helpers
● Task.WhenAll()
● Task.WhenAny()
● Task.WaitAll()
● Task.WhenAny()
● Task.Delay()
● Task.Run()
● Task.Yield()

38. ConfigureAwait
Public async void Click(object sender, EventArgs args)
{
var str = await service.DownloadString(Url).ConfigureAwait(false);
UxTextBlock.Text = str; // Runtime Error
}
Public async void Click(object sender, EventArgs args)
{
var str = await service.DownloadString(Url);
UxTextBlock.Text = str;
}

39. Task Completion Source
EAP
APM
TAP
SetResult
SetException

40. Task Completion Source
public Task UseBackgroundWorker()
{
var tcs = new TaskCompletionSource<double>();
var backgroundWorker = new BackgroundWorker();
backgroundWorker.DoWork += (o, e) =>
{
Thread.Sleep(2000);
e.Result = 42;
};
backgroundWorker.RunWorkerCompleted += (o, e) =>
{
if (e.Error != null)
{
tcs.SetException(e.Error);
}
else
{
tcs.SetResult((double)e.Result);
}
};
return tcs.Task;
}

41. Cancellation
CancellationTokenSource
CancellationTokenSource.Cancel()
CancellationToken
Cancellation.Token.IfCancellationRequested
CancellationToken.ThrowIfCancellationRequest

42. Demo

43. Async Synchronization

44. Lock
Task t;
lock
{
t = httpClient.GetAsync();
}
var result = await t;

45. Async lock
SemaphoreSlim _mutex = new SemaphoreSlim(1);
…
public async Task Method()
{
await _mutex.WaitAsync();
try
{
var result =
await httpClient.GetAsync(Url);
}
finally
{
_mutext.Release();
}
}
AsyncLock _mutex = new AsyncLock();
…
public async Task Method()
{
using (await _mutex.LockAsync())
{
var result =
await httpClient.GetAsync(Url);
}
}
Nito.AsyncEx

46. Exceptions
Wait()
WaitAll()
WaitAny()
Result
AggregationException

47. Aggregation Exception
Task task1 = Task.Factory.StartNew(() => LongOperationAsync());
try
{
task1.Wait();
}
catch (AggregateException ae)
{
ae.Handle((x) =>
{
if (x is MyException)
{
Console.WriteLine("HandleException.");
return true;
}
return false;
});
}

48. The end