Learning Path

Getting Started with Reactive Programming—Asynchronous Java, Promises, Actors, and Reactive Streams

Instructor Susan Conant
Time to complete: 5h 22m

Published byO'Reilly Media, Inc.

CreatedOctober 2017

What is this learning path about, and why is it important?

Today, users expect the applications that you create for them to be performant and smooth. Having to wait for an application that stops responding while it awaits a reply from a server or as a result of other network-related latencies is no longer a tolerable part of the user experience. Combine this with the growing use of microservices and the functional requirements of that architecture, and it’s easy to see why reactive and asynchronous applications are growing in popularity. Asynchronous (or nonblocking) programming along with reactive (or event-driven) applications work by scheduling network I/O operations in a manner that allows them to then work on other tasks without waiting—or, from the user’s perspective, becoming unresponsive—for network or server-related tasks to finish. Clearly, this is the experience you want for your users, but what is the best way for you, as an intermediate-to-advanced level Java developer, to build reactive and asynchronous applications?

In this learning path, you’ll learn how to apply the latest concurrency techniques to develop state of the art reactive Java applications. Your hosts, Richard Warburton and Raoul-Gabriel Urma, begin by giving you a thorough introduction to asynchronous programming concepts and methods, such as nonblocking I/O and the problems with using callbacks as a concurrency model. Next, you’ll refactor several projects using the CompletableFuture class in Java 8; see what problems they solve for Java developers; and learn how to use the Java 8 API productively in practice. After that, you’ll work with Actors in Akka and explore the concepts behind the actor model; how the Akka toolkit compares with other concurrency concepts; and how to use the Akka API. Finally, you’ll see how RxJava compares with other concurrency concepts, and learn how to use the library productively in practice.

What you’ll learn—and how you can apply it

  • Programming event-driven—reactive—code in Java
  • The benefits of working with asynchronous and nonblocking programming techniques
  • The various approaches that you can apply to help your applications safely and easily achieve concurrency
  • How to implement reactive code in a readable and maintainable way using Java 8’s CompletableFuture class
  • How to use the new features in the Java 8 API to enhance your productivity
  • Understand how to program event-driven reactive code using Actors and Akka
  • How to implement reactive code in a readable and maintainable way using RxJava
  • Gain experience building reliable and performant Java apps in a microservices/Service-Oriented Architecture (SOA) model

This learning path is for you because…

  • You’re a software architect, senior developer, or developer who needs to understand how to build Java applications that can scale-out to large numbers of users
  • You want to understand how to build Java applications that are reliable and performant in a microservices or SOA model
  • You need to understand how to build Java applications that can communicate efficiently with other systems and services within your organization


  • You should be a competent core Java developer
  • You should be able to import a Maven project and run tests
  • You should have a basic understanding of Java 8 Lambdas, but an in-depth knowledge of Java 8 APIs isn’t essential
  • You do not need to have prior experience with any of the things that we’ll be learning in the course

Materials or downloads needed in advance: None