Akka Streams is a powerful library for building and processing streams of data using the actor-based Akka framework. It provides a Reactive Streams implementation, which is a specification for asynchronous, non-blocking, backpressure-enabled stream processing.

Akka Streams is designed to handle large or infinite streams of data efficiently, allowing developers to define and execute stream-based workflows in a modular and composable manner.

Core Features of Akka Streams :

1. Asynchronous and Non-Blocking: Akka Streams ensures efficient resource usage by processing data asynchronously, allowing for better performance in I/O-bound applications.
2. Backpressure: It uses backpressure to manage flow control, ensuring that faster producers do not overwhelm slower consumers.
3. Composable API: It provides a fluent, declarative API for defining complex data processing pipelines.
4. Integration with Akka: It integrates seamlessly with Akka actors, enabling advanced use cases such as distributed stream processing.
5. Fault Tolerance: Streams can recover from failures, making them robust for real-world scenarios.

val source = Source(1 to 10) // Emits numbers from 1 to 10?

val source = Source(1 to 10) // Emits numbers from 1 to 10?

val flow = Flow[Int].map(_ * 2) // Multiplies each element by 2?

val runnableGraph = source.via(flow).to(sink)
runnableGraph.run()?

import akka.actor.ActorSystem
import akka.stream.scaladsl.{Source, Sink, Flow}
import akka.stream.Materializer

implicit val system: ActorSystem = ActorSystem("AkkaStreamsExample")
implicit val materializer: Materializer = Materializer(system)

val source = Source(1 to 10) // Emit numbers from 1 to 10
val flow = Flow[Int].map(_ * 2) // Multiply each number by 2
val sink = Sink.foreach[Int](println) // Print each number

val runnableGraph = source.via(flow).to(sink)
runnableGraph.run() // Runs the stream?

2
4
6
8
10
12
14
16
18
20?

Reactive Streams is a standard specification designed to provide asynchronous, non-blocking, and backpressure-enabled data stream processing. It defines a set of interfaces and rules for building and handling reactive data streams in a consistent manner, allowing for the interoperability of different implementations (like Akka Streams, Project Reactor, and RxJava).

Key Goals of Reactive Streams :

1. Asynchronous and Non-blocking: Enable systems to handle data streams asynchronously without blocking threads, ensuring efficient use of system resources.
2. Backpressure: Prevent faster producers from overwhelming slower consumers by providing a mechanism to manage the flow of data.
3. Interoperability: Provide a standard interface so different libraries and tools can work together seamlessly.
4. Scalability: Support systems that can scale effectively for both high and low-throughput scenarios.

Backpressure in Reactive Streams :

Backpressure is the ability of a Subscriber to signal the Publisher how many data items it can handle at a time. This prevents the Publisher from overwhelming the Subscriber with more data than it can process.

Example:

• A Subscriber requests 5 items from the Publisher using request(5).
• The Publisher sends only 5 items.
• Once the Subscriber processes these items, it can request more data.

import org.reactivestreams.*;

public class ReactiveStreamsExample {
    public static void main(String[] args) {
        Publisher<Integer> publisher = subscriber -> {
            subscriber.onSubscribe(new Subscription() {
                @Override
                public void request(long n) {
                    for (int i = 1; i <= n; i++) {
                        if (i > 10) {
                            subscriber.onComplete();
                            return;
                        }
                        subscriber.onNext(i);
                    }
                }

                @Override
                public void cancel() {
                    System.out.println("Subscription canceled");
                }
            });
        };

        Subscriber<Integer> subscriber = new Subscriber<>() {
            @Override
            public void onSubscribe(Subscription subscription) {
                System.out.println("Subscribed");
                subscription.request(5); // Request 5 items
            }

            @Override
            public void onNext(Integer item) {
                System.out.println("Received: " + item);
            }

            @Override
            public void onError(Throwable throwable) {
                System.err.println("Error: " + throwable.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("Complete");
            }
        };

        publisher.subscribe(subscriber);
    }
}?

Subscribed
Received: 1
Received: 2
Received: 3
Received: 4
Received: 5
Complete?

Implementations of Reactive Streams :

1. Akka Streams:

   • Part of the Akka framework.
   • Provides a high-level, composable API for building reactive streams.

2. Project Reactor:

   • A reactive programming library for building non-blocking applications in Java.
   • Provides Mono (1 item) and Flux (multiple items) types.

3. RxJava:

   • Reactive Extensions for Java.
   • Inspired by the Observer pattern with rich operators for transforming and combining streams.

4. Spring WebFlux:

   • A reactive web framework built on Project Reactor.

5. Vert.x:

   • Reactive toolkit for building distributed systems.

Akka Streams and Akka Actors are both parts of the Akka toolkit, but they serve different purposes and address different programming paradigms. Here’s a detailed comparison of the two:

Purpose and Focus :

1. Akka Actors:

   • Designed for message-driven concurrency and distributed systems.
   • The core concept is an actor, which encapsulates state and behavior, processes messages asynchronously, and communicates with other actors via message passing.
   • Focuses on managing complex, concurrent workflows using actor-based programming.

2. Akka Streams:

   • Built on top of Akka Actors but focuses on stream-based, reactive data processing.
   • Provides a declarative, composable API for working with data streams (e.g., processing, transforming, and handling backpressure).
   • Focuses on efficiently managing data flow in a pipeline-like manner.

Programming Model :

class MyActor extends Actor {
  def receive: Receive = {
    case msg: String => println(s"Received message: $msg")
    case _           => println("Unknown message")
  }
}?

val source = Source(1 to 10)
val sink = Sink.foreach[Int](println)
val flow = source.to(sink)
flow.run()?

val decider: Supervision.Decider = {
  case _: ArithmeticException => Supervision.Resume
  case _                       => Supervision.Stop
}?

val decider: Supervision.Decider = {
  case _: IllegalStateException => Supervision.Restart
  case _                         => Supervision.Stop
}?

val decider: Supervision.Decider = {
  case _: IllegalArgumentException => Supervision.Stop
  case _                           => Supervision.Resume
}?

val flowWithSupervision = myFlow.withAttributes(ActorAttributes.supervisionStrategy(decider))?

val source = Source(1 to 10)
val flow = Flow[Int].map(_ * 2)
val sink = Sink.foreach(println)
val runnableGraph = source.via(flow).to(sink)
runnableGraph.run()?