Practical Reactive Streams with Akka

Implement asynchronous, non-blocking reactive streams with backpressure

This course will show you how to use Akka to build asynchronous, non-blocking reactive streams with back-pressure.
Using practical examples we'll cover both the simple API and the GraphDSL.
Learn how to correctly implement asynchronous boundaries, parallelism, integration with Akka Actors, and more.

Pre-requisites

This is a follow-on course to the Practical Concurrency with Akka course. You should have completed that course and be comfortable creating actors using the Akka Typed API before starting this course.

Contents - contains 8.5 hours of video - equivalent to 2 days of live training.

Having problems? check the errata for this course.

Introduction
What are reactive streams? 11m 39s
Creating our first stream
A note about external sources 1m 29s
Using the Akka libraries 8m 11s
Creating a source 4m 52s
Creating a sink 3m 55s
Creating a flow 4m 20s
Building and running a graph 7m 12s
Simple Sources and Sinks
Finite Sources 6m 3s
Infinite Sources 7m 42s
Basic source operators 4m 5s
Creating sinks 2m 59s
Graph convenience methods 5m 43s
Simple Flows
Map and Filter 6m 56s
MapConcat 4m 12s
Grouped 2m 8s
Flows of generic data types 10m 41s
Combining flows with sinks and sources 9m 20s
Exercise 1 - Big Primes
Exercise 2m 42s
Walkthrough 10m 17s
Materialized values
What are materialized values? 8m 46s
The fold method and selecting a materialized value for the graph 10m 19s
Terminating the actor system 3m 32s
The reduce method 3m 56s
Stream lifecycles
Re-using graph objects 2m 31s
Converting infinite streams to finite streams with take and limit 4m 38s
The takeWhile and takeWithin functions 5m 0s
Logging
Logging elements in a stream 9m 58s
Back pressure and graph performance
Asynchronous boundaries 10m 25s
Introducing back-pressure 5m 40s
Adding buffers to the graph 6m 28s
Other overflow strategies 3m 42s
Parallelism 9m 41s
Exercise 2
Instructions to create an optimised graph with a materalised value 12m 3s
The GraphDSL
Why do we need the GraphDSL? 3m 45s
Introducing the GraphDSL Syntax 5m 12s
Constructing a simple Graph using the GraphDSL 14m 20s
Understanding the Graph Construction and introducing Asynchronous Boundaries 11m 30s
Complex flow types
Introducing fan-in and fan-out shapes 3m 42s
Broadcast and merge 18m 38s
Using Balance for parallelilsm 14m 48s
Exercise 3 - implementing parallelism in GraphDSL 5m 15s
Uniform fan-in and fan-out shapes 12m 40s
Non uniform fan-in and fan-out shapes 17m 51s
Graphs with multiple sources and sinks
Combining sources with a fan-in shape 18m 20s
Sending to an interim sink with alsoTo 5m 26s
Diverting outliers to a different sink with divertTo 10m 50s
Non-runnable or partial graphs
Creating and combining open shapes 15m 20s
Using open shapes outside the graphDSL 2m 32s
Using actors in graphs
Adding an actor to our project 5m 37s
Using actors as flows 8m 38s
Using actors as sinks 7m 50s
Advanced backpressure
Conflate 14m 0s
Extrapolate and expand 5m 58s
The java flow package
Java's reactive streams interfaces 17m 7s
Case Study - Blockchain mining
Introducing the case study 19m 4s
Exercise 4 - receive transactions with backpressure 5m 20s
Walkthrough 5m 6s
Exercise 5 - mine using actors and apply the result 2m 40s
Walkthrough 8m 5s
Creating a circular graph 18m 13s
APPENDIX
A simple introduction to blockchains 8m 36s

Improve your coding skills from beginner to expert with the largest online Java e-learning platform

Practical Reactive Streams with Akka

Pre-requisites

Contents - contains 8.5 hours of video - equivalent to 2 days of live training.

Introduction

What are reactive streams?

Creating our first stream

A note about external sources

Using the Akka libraries

Creating a source

Creating a sink

Creating a flow

Building and running a graph

Simple Sources and Sinks

Finite Sources

Infinite Sources

Basic source operators

Creating sinks

Graph convenience methods

Simple Flows

Map and Filter

MapConcat

Grouped

Flows of generic data types

Combining flows with sinks and sources

Exercise 1 - Big Primes

Exercise

Walkthrough

Materialized values

What are materialized values?

The fold method and selecting a materialized value for the graph

Terminating the actor system

The reduce method

Stream lifecycles

Re-using graph objects

Converting infinite streams to finite streams with take and limit

The takeWhile and takeWithin functions

Logging

Logging elements in a stream

Back pressure and graph performance

Asynchronous boundaries

Introducing back-pressure

Adding buffers to the graph

Other overflow strategies

Parallelism

Exercise 2

Instructions to create an optimised graph with a materalised value

The GraphDSL

Why do we need the GraphDSL?

Introducing the GraphDSL Syntax

Constructing a simple Graph using the GraphDSL

Understanding the Graph Construction and introducing Asynchronous Boundaries

Complex flow types

Introducing fan-in and fan-out shapes

Broadcast and merge

Using Balance for parallelilsm

Exercise 3 - implementing parallelism in GraphDSL

Uniform fan-in and fan-out shapes

Non uniform fan-in and fan-out shapes

Graphs with multiple sources and sinks

Combining sources with a fan-in shape

Sending to an interim sink with alsoTo

Diverting outliers to a different sink with divertTo

Non-runnable or partial graphs

Creating and combining open shapes

Using open shapes outside the graphDSL

Using actors in graphs

Adding an actor to our project

Using actors as flows

Using actors as sinks

Advanced backpressure

Conflate

Extrapolate and expand

The java flow package

Java's reactive streams interfaces

Case Study - Blockchain mining

Introducing the case study

Exercise 4 - receive transactions with backpressure

Walkthrough

Exercise 5 - mine using actors and apply the result