Practical Java concurrency with the Akka Actor Model

Course Curriculum

Chapter 1: Chapter 1 – Introduction

Lecture 1: Introduction

Lecture 2: Course files

Lecture 3: How to get support for this course

Chapter 2: Chapter 2 – Why do we need Akka?

Lecture 1: An introduction to our first multi-threading example

Lecture 2: Basic concurrent programming in core Java

Lecture 3: Why concurrent programming in Java is difficult

Chapter 3: Chapter 3 – The Actor Model

Lecture 1: The concepts of the actor design pattern

Lecture 2: What is an actor?

Lecture 3: Why does this model work?

Chapter 4: Chapter 4 – Creating our first actor

Lecture 1: Setting up an Akka project

Lecture 2: Creating our first actor – constructors

Lecture 3: Creating our first actor – defining behaviors

Lecture 4: Instantiating actors and sending messages

Chapter 5: Chapter 5 – Going further with actors

Lecture 1: Expanding the receiveBuilder

Lecture 2: Creating child actors

Lecture 3: Actor paths

Lecture 4: Starting the big prime example

Lecture 5: Exercise 1 – creating actors

Lecture 6: Exercise 1 – walktrhrough

Chapter 6: Chapter 6 – Going further with messages

Lecture 1: Creating a custom message type

Lecture 2: Applying the custom message type to a behavior

Lecture 3: Using interfaces to support multiple message types

Lecture 4: Understanding message delivery guarantees

Chapter 7: Chapter 7 – Case Study 1 – Simulation example

Lecture 1: Introducing the case study

Lecture 2: Architecting the solution

Lecture 3: Implementing the case study

Lecture 4: Scheduling and timers

Chapter 8: Chapter 8 – Going further with behaviors

Lecture 1: Behaviors can change over time

Lecture 2: Exercise 2 – Changing behaviors

Lecture 3: Exercise 2 – walkthrough

Chapter 9: Chapter 9 – Actor lifecycles

Lecture 1: Actors stopping themselves

Lecture 2: Stopping child actors

Lecture 3: Actor lifecycle methods

Chapter 10: Chapter 10 – Logging

Lecture 1: Logging messages from actors

Lecture 2: Configuring log level output

Chapter 11: Chapter 11 – Case Study 2 – Blockchain mining example

Lecture 1: A simple introduction to blockchains

Lecture 2: Introducing the case study

Chapter 12: Chapter 12 -Unit Testing

Lecture 1: Creating a message handler that needs testing

Lecture 2: Unit testing with log messages

Lecture 3: Unit testing with response messages

Chapter 13: Chapter 13 – Akka interraction patterns

Lecture 1: The tell and forget and the request-response pattern

Lecture 2: The ask pattern

Lecture 3: Getting data out of akka

Chapter 14: Chapter 14 – Actor Supervision

Lecture 1: Introduction to multi-threaded blockchain mining

Lecture 2: Preparing our project to be ready for supervision

Lecture 3: Watching actors (supervision)

Lecture 4: Dealing with actors that crash

Lecture 5: Shutting down all the child actors

Chapter 15: Chapter 15 – Production standard techniques

Lecture 1: Exercise 3 – Ensuring immutable state

Lecture 2: Actors sending messages to themselves

Lecture 3: Stashing messages

Lecture 4: Using routers for simultaneous actor operations

Chapter 16: Chapter 16 – Next steps

Lecture 1: Other features of Akka that might be of interest

Lecture 2: Bonus lecture