That Conference 2017, Kalahari Resort, Lake Delton, WI
Concurrent Programming in .NET – Jason Bock (@JasonBock)

Day 2, 8 Aug 2017

Disclaimer: This post contains my own thoughts and notes based on attending That Conference 2017 presentations. Some content maps directly to what was originally presented. Other content is paraphrased or represents my own thoughts and opinions and should not be construed as reflecting the opinion of the speakers.

Executive Summary

• Doing concurrency correctly is very hard when doing it at a lower level
• Don’t use Thread, ThreadPool anymore
• Learn and use async/await

Background

• Concurrency is tough, not as easy as doing things sequentially
• Games are turn-based
  • But interesting exercise to do chess concurrently
  • Much more complicated, just as a game
• We’ll just look at typical things that people struggle with

Terms

• Concurrency – Work briefly and separately on each task, one at a time
• Parallelism – People all working at the same time, doing separate tasks
• Asynchronous – One you start a task, you can go off and do something else in the meantime

Recommendations

• Stop using Thread, ThreadPool directly
• Understand async/await/Task
• Use locks wisely
• Use concurrent and immutable data structures
• Let someone else worry about concurrency (actors)

Stop Using Thread, ThreadPool

• This was the way to do concurrency back in .NET 1.0
• Diagram – Concurrent entities on Windows platform
  • Process – at least one thread
  • Thread – separate thread of execution
  • Job – group of processes
  • Fiber – user-level concurrent tasks
• But mostly we focus on process and thread
• Example–multiple threads
  • Use Join to observe at end
• Problems
  • Stack size
  • # physical cores
• # Cores
  • May not really be doing things in parallel
  • More threads than cores–context switch and run one at a time on a core
  • Context switches potentially slow things down
  • Don’t just blindly launch a bunch of threads
• Memory
  • Each thread -> 1 MB memory
• ThreadPool is an improvement
  • You don’t know when threads are complete
  • Have to use EventWaitHandle, WaitAll
  • Lots of manual works
  • At least threads get reused
• Existing code that uses Threads works just fine

Async/Await/Tasks

• Models
  • Asynchronous Programming Model (APM)
  • Event-based Asynchronous Patter (EAP)
  • Task-Based Asynchrony (TAP)
• Demo – console app
  • AsyncContext.Run – can’t call async method from non-async method
  • AsyncContext – from Stephen Cleary – excellent book
  • This goes away in C# 7.1 – compiler will allow calling async method
  • Reading file
• Misconception – that you create threads when you call async method
  • No, not true
  • Just because method is asynchronous, it won’t necessarily be on another thread
• Use async when doing I/O bound stuff
  • Calling ReadLineAsync, you hit IO Completion Point; when done, let caller know
  • When I/O is done, calling thread can continue
  • Asynchronous calls may also not necessarily hit IOCP
• If you do I/O in non-blocking way on a thread, you can then use thread to do CPU work while the I/O is happening
  • Performance really does matter–e.g. use fewer servers
• When you call async method, compiler creates asynchronous state machine
  • Eric Lippert’s continuation blog post series
• Task object has IsCompleted
  • Generated code need to first check state to see if task completed right away
• Good news is–that you don’t need to write the asynch state machine plumbing code
• Can use Tasks to run things in parallel
  • Task.Run(() => ..)
  • await Task.WhenAll(t1, t2);
• Tasks are higher level abstraction than threads
• Don’t ever do async void
  • Only use it for event handlers
• Keep in mind that async tasks may actually run synchronously, under the covers

Demo – Evolving Expressions

• Code uses all cores available

Locks

• Don’t use them (or try not to use them)
• If you get them wrong, you can get deadlocks
• Don’t lock on
  • Strings – You could block other uses of string constant
  • Integer – you don’t lock on the same thing each time, since you lock on boxed integer
• Just use object to lock on
• Interlocked.Add/Decrement
  • For incrementing/decrementing integers
  • Faster
• Tool recommendation: benchmark.net
• SpinLock
  • Enter / Exit
  • Spins in a while loop
  • Can be slower than lock statement
  • Don’t use SpinLock unless you know it will be faster than other methods

Data Structures

• List<T> is not thread-safe
• ConcurrentStack<T>
  • Use TryPop
• ImmutableStack<T>
  • When you modify, you must capture the new stack, result of the operation
  • Objects within the collection can change

Actors

• Service Fabric Reliable Actors
• Benefits
  • Resource isolation
  • Asynchronous communication, but single-threaded
    • The actor itself is single-threaded
    • So in writing the actor, you don’t need to worry about thread safety

Demo – Actors – Using Orleans

• “Grains” for actors