Practical Java concurrency with the Akka Actor Model

Practical Java concurrency with the Akka Actor Model

What you’ll learn

Concurrent Java programming using the Actor Framework
How the Actor Model works and can be used as a better alternatives to Thread creation
How to use the core Akka libraries to build robust, thread-safe, concurrent applications

Requirements

Basic Java knowledge
Some existing Java multi-threading programming is helpful but not essential
No knowledge of Akka or Scala is needed

Description

This course will cover how to use the Actor Model provided by the Akka framework to build robust, thread-safe concurrent applications with Java.We’ll be leaving behind the traditional problems with multi-threaded programming, such as dealing with non-thread safe variables, deadlocks, thread interruptions and more. Akka gives us a completely different approach. Instead of creating threads, using synchronization, locks, semaphores and countdownlatches, we’ll learn how the actor model gives us a very different way to approach concurrent programming. Learning the actor model from scratch can be a challenge, so in this course we build up the knowlege step by step, meaning you’ll have no problems following along and understanding everything we do. And the course is full of practical real-world scenarios, so that you’ll be able to take what you learn and apply it to your own projects. Our main case study is that we’ll be building a basic blockchain mining application.Please note that although Akka is built in Scala, absolutely no Scala knowledge is needed for this course. This course covers Akka with Java and we won’t be writing any Scala code. It’s ideal for Java developers with some experience (although you certainly don’t need to be an expert). This course covers the newer Akka Typed API only.

Overview

Section 1: Chapter 1 – Introduction

Lecture 1 Introduction

Lecture 2 Course files

Lecture 3 How to get support for this course

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

Lecture 4 An introduction to our first multi-threading example

Lecture 5 Basic concurrent programming in core Java

Lecture 6 Why concurrent programming in Java is difficult

Section 3: Chapter 3 – The Actor Model

Lecture 7 The concepts of the actor design pattern

Lecture 8 What is an actor?

Lecture 9 Why does this model work?

Section 4: Chapter 4 – Creating our first actor

Lecture 10 Setting up an Akka project

Lecture 11 Creating our first actor – constructors

Lecture 12 Creating our first actor – defining behaviors

Lecture 13 Instantiating actors and sending messages

Section 5: Chapter 5 – Going further with actors

Lecture 14 Expanding the receiveBuilder

Lecture 15 Creating child actors

Lecture 16 Actor paths

Lecture 17 Starting the big prime example

Lecture 18 Exercise 1 – creating actors

Lecture 19 Exercise 1 – walktrhrough

Section 6: Chapter 6 – Going further with messages

Lecture 20 Creating a custom message type

Lecture 21 Applying the custom message type to a behavior

Lecture 22 Using interfaces to support multiple message types

Lecture 23 Understanding message delivery guarantees

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

Lecture 24 Introducing the case study

Lecture 25 Architecting the solution

Lecture 26 Implementing the case study

Lecture 27 Scheduling and timers

Section 8: Chapter 8 – Going further with behaviors

Lecture 28 Behaviors can change over time

Lecture 29 Exercise 2 – Changing behaviors

Lecture 30 Exercise 2 – walkthrough

Section 9: Chapter 9 – Actor lifecycles

Lecture 31 Actors stopping themselves

Lecture 32 Stopping child actors

Lecture 33 Actor lifecycle methods

Section 10: Chapter 10 – Logging

Lecture 34 Logging messages from actors

Lecture 35 Configuring log level output

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

Lecture 36 A simple introduction to blockchains

Lecture 37 Introducing the case study

Section 12: Chapter 12 -Unit Testing

Lecture 38 Creating a message handler that needs testing

Lecture 39 Unit testing with log messages

Lecture 40 Unit testing with response messages

Section 13: Chapter 13 – Akka interraction patterns

Lecture 41 The tell and forget and the request-response pattern

Lecture 42 The ask pattern

Lecture 43 Getting data out of akka

Section 14: Chapter 14 – Actor Supervision

Lecture 44 Introduction to multi-threaded blockchain mining

Lecture 45 Preparing our project to be ready for supervision

Lecture 46 Watching actors (supervision)

Lecture 47 Dealing with actors that crash

Lecture 48 Shutting down all the child actors

Section 15: Chapter 15 – Production standard techniques

Lecture 49 Exercise 3 – Ensuring immutable state

Lecture 50 Actors sending messages to themselves

Lecture 51 Stashing messages

Lecture 52 Using routers for simultaneous actor operations

Section 16: Chapter 16 – Next steps

Lecture 53 Other features of Akka that might be of interest

Lecture 54 Bonus lecture

Novice and experienced Java developers who need to enhance their concurrent programming skills.

Course Information:

Udemy | English | 6h 55m | 2.74 GB
Created by: Matt Greencroft

You Can See More Courses in the Developer >> Greetings from CourseDown.com