materialize the flow and get the value of the FoldSink Val runnable: RunnableGraph] = source.toMat(sink)(Keep.right) connect the Source to the Sink, obtaining a RunnableGraph Scala copy source val source = Source(1 to 10) Thanks to Flows being a description of the processing pipeline they are immutable, thread-safe, and freely shareable, which means that it is for example safe to share and send them between actors, to have one actor prepare the work, and then have it be materialized at some completely different place in the code. Materialization is the process of allocating all resources needed to run the computation described by a Graph (in Akka Streams this will often involve starting up Actors). It is important to remember that even after constructing the RunnableGraph by connecting all the source, sink and different operators, no data will flow through it until it is materialized. After a stream is properly constructed by having both a source and a sink, it will be represented by the RunnableGraph type, indicating that it is ready to be executed. It is possible to attach a Flow to a Source resulting in a composite source, and it is also possible to prepend a Flow to a Sink to get a new sink. RunnableGraph A Flow that has both ends “attached” to a Source and Sink respectively, and is ready to be run(). Flow An operator which has exactly one input and output, which connects its upstream and downstream by transforming the data elements flowing through it. Sink An operator with exactly one input, requesting and accepting data elements, possibly slowing down the upstream producer of elements. Linear processing pipelines can be expressed in Akka Streams using the following core abstractions: Source An operator with exactly one output, emitting data elements whenever downstream operators are ready to receive them.
/001_how-to-broadcast-steam-4587132-81f02e49b0794ea492513e215a00c2dc.jpg "source unpack cant steam broadcast")
This is a thread-pool friendly design, since entities that need to wait (a fast producer waiting on a slow consumer) will not block the thread but can hand it back for further use to an underlying thread-pool. This way they can slow down a fast producer without blocking its thread.
When we talk about asynchronous, non-blocking backpressure, we mean that the operators available in Akka Streams will not use blocking calls but asynchronous message passing to exchange messages between each other.
#SOURCE UNPACK CANT STEAM BROADCAST FULL#
For the full list of built-in operators see the operator index Examples of operators are map(), filter(), custom ones extending GraphStages and graph junctions like Merge or Broadcast. Operator The common name for all building blocks that build up a Graph. Graph A description of a stream processing topology, defining the pathways through which elements shall flow when the stream is running. Means that a certain operation does not hinder the progress of the calling thread, even if it takes a long time to finish the requested operation. In the context of Akka Streams back-pressure is always understood as non-blocking and asynchronous. Back-pressureĪ means of flow-control, a way for consumers of data to notify a producer about their current availability, effectively slowing down the upstream producer to match their consumption speeds. Buffer sizes are always expressed as number of elements independently from the actual size of the elements. All operations transform and transfer elements from upstream to downstream. Element An element is the processing unit of streams. Akka Stream processing entities have bounded “mailboxes” that do not drop.īefore we move on, let’s define some basic terminology which will be used throughout the entire documentation: Stream An active process that involves moving and transforming data. This property of bounded buffers is one of the differences from the actor model, where each actor usually has an unbounded, or a bounded, but dropping mailbox.
Each of these entities executes independently (and possibly concurrently) from the others while only buffering a limited number of elements at any given time. Translated to everyday terms, it is possible to express a chain (or as we see later, graphs) of processing entities. This latter property is what we refer to as boundedness, and it is the defining feature of Akka Streams. Implementation platform(":akka-bom_$"Īkka Streams is a library to process and transfer a sequence of elements using bounded buffer space. LibraryDependencies += "" %% "akka-stream" % AkkaVersion Maven To use Akka Streams, add the module to your project: sbt val AkkaVersion = "2.6.17"
0 kommentar(er)
