Working with Channels in .net core

Dotnet Konferansı 2021

Transcript

1. Working with Channels in Alper Hankendi
2. 20 2019 KrakenD API Gateway About Me Working as Product Engineering Director at Hepsiburada 20 Years Experience… approximately (professional) Ninja Developer Like to build useless stuff Drummer, Brewer and…. Father @alper_hankendi github.com/alperhankendi
3. 33 2020 Authorization granularity • What is a Channels • Why use Channels • Bounded/Unbounded Channels • Writing Channels • Reading Channels • Channel Types • Benchmark • Dealing with back pressure • Async data pipelines AGENDA
4. 4 What is A Channel ? A channel is a data structure that allows one thread to communicate with another thread. In .NET, this was usually done by using a shared variable that supports concurrency (by implementing some synchronization/locking mechanism). Channels, on the other hand, can be used to send messages directly between threads without any external synchronization or locking required. Logically a channel is effectively an efficient, thread-safe queue. The API is designed to be Used with async/await in C#.
5. 5 What is A Channel ? Consumer task which performs the processing steps for each message. It reads from the channel, processing each message in turn. A benefit of this approach is that my producer/consumer functionality has now been separated and data can be passed via the channel. Create more producer or consumer tasks to achieve higher throughput
6. 6 Why Use System.Threading.Channels - “Producer/Consumer” problems are everywhere, in all facets of our lives. - When it comes to multi-threading, one of the first pattern that emerges in the producer-consumer pattern - It is a powerful tool for simplifying many producers & consumers patterns in .NET. - Anytime you need to exchange items between “Tasks” you will find channels is a pretty convenient and straightforward way to get started. - Channels enable concurrency patterns
7. 7 Channels Enable Concurrency Pattern The relationship between concurrency and parallelism is commonly misunderstood. In fact, two task being concurrent doesn’t mean that they’ll run in parallel. The following quote by Martin Kleppmann has stood out in my mind when it comes to concurrency: google “youtube: Concurrency is not parallelism by Rob Pike For defining concurrency, the exact time doesn’t matter: we simply call two operations concurrent if they are both unaware of each other, regardless of the physical time at which they occurred. “Designing Data-Intensive Applications” by Martin Kleppmann
8. CreateBounded<T>: creates a channel with a finity capacity. In that case, it’s possible to develop a producer/consumer pattern which accommodates this limit. Attempts to write the channel when it contains the maximum allowed number of items result in behavior according to the “mode” specified when the channel is created 8 Channel Factory & Bounded Channels
9. CreateUnbounded<T> : creates a channel with an unlimited capacity. This can be quite dangerous if your producer outpaces you the consumer. The channel will keep accepting new items. When the consumer is not keeping up, the number of queyed items will keep increasing. It’s possible to run out of available memory in this scenario. 9 Unbounded Channels
10. 10 Built-In Channel Implementations
11. 11 Writing to a Channel
12. 12 Reading From a Channel
13. Testing the throughput and memory allocation on an unbounded channel when writing an element and then reading out that element a million times 13 My Channel vs Channel
14. 14 With ‘MyChannel’ Implementation
15. 15 With dotnet Channels
16. 16 Benchmark Custom Imp vs. Channels
17. 17 Channel Samples source: https://github.com/stevejgordon/ChannelSample
18. 18 Channel Samples source: https://github.com/stevejgordon/ChannelSample
19. 19 Channel Samples source: https://github.com/stevejgordon/ChannelSample
20. 20 Channel Samples source: https://github.com/stevejgordon/ChannelSample
21. 21 RECAP
22. 22 Use Case; async data pipelines
23. 23 Async Data Pipelines
24. 24 Dealing With Back pressure
25. The stage where we retrieve the license file from github might cause experience backpressure because retrieving the license is slower than ‘Read File stage’. It makes sense to increase the capacity of ‘Get License stage’ and that’s where Split<T> and Merge<T> 25 Dealing With Back pressure
26. 26 Dealing With Back pressure- Multiplexer Split<T> is a method that takes an input channel and distributes its messages amongst several outputs. That way we can let several threads concurrently handle the message processing.
27. Merge<T> is the opposite operation. It takes multiple input channels and consolidates them in a single output. 27 Dealing With Back pressure - Demultipler
28. 28 Async Data Pipelines
29. 29 Questions ? @alper_hankendi github.com/alperhankendi