Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Working with Channels in .net core

Working with Channels in .net core

Dotnet Konferansı 2021

Bc7114ad3cf4d2d703dc71782e61ba43?s=128

Alper Hankendi

February 20, 2021
Tweet

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