Beskrivning

The course kicks off with a full day focusing on Concurrent Programming. This subject stretches from a brief introduction of the basic implementation of low level Threads, lingering over the Executor Framework, with its vast number of concepts, to the enhancements provided by the introduction of lambda expressions and the Streams API in Java.

The second day of the course will cover numerous Design Patterns used heavily in the core Java APIs and of course frequent in complex applications. We will cover main parts of the
classical Design Patterns catalogue, but also introduce some new additions such as DRY, SOLID etc. Some patterns have gained considerably from the introduction of generics and the support of functional programming in modern Java. We will check out these possibilities!

State Machines are gaining more and more interest as digitalization moves on into almost every electronic device in our lives. In Java, state machines can easily be designed following a robust pattern implemented using modern Java technology.

Day three will cover some of the latest additions to the Java programming language. Modules in Java offer a new level of packaging and supports customization of deliverables needed for running an application.

Performance issues will always be important for complex applications. W will have a look at the Java Flight Recorder and Java Mission Control that now are fully available measuring
behavior of your applications.

Both the aforementioned parts are crucial when you set out to build a library. Apart from the pure technical aspects there are some other issues you have to address in order to deliver a library to please your potential clients.

Finally we take a look into the crystal ball, checking up what lies in the near future in the Java evolution, revealing features that will appear in upcoming Java releases.

Hands-On

Every chapter is backed by complete examples that are ready to run. In addition there are a number of exercises that will be addressed and discussed during the course.

Documentation

• Digital copy of course slides
• Complete code for all examples/exercises

Contents:

1. Threads
 Sequential vs. parallel processing of data
o Utilizing available resources efficiently
o Order of output may differ from order of output
 Introduction to basic Thread programming
o Interface Runnable and class Thread
o synchronized code
o Thread Lifecycle
o Concurrent programming pitfalls
 Case Study – A Storage
o Consumer-Producer using low level Thread interaction

2. Concurrent Collections
 Concurrent Collections in Java
o CopyOnWriteArrayList
o ConcurrentHashMap
o BlockingQueue
o CountDownLatch
 Case Study – A Blocking Storage
o Consumer-Producer using a BlockingQueue

3. Executor Framework
 Executor Framework
o Callable, Future
 Replacing Runnable
o Executors
 SingleThreadExecutor
 FixedThreadPool
 CachedThreadPool
 Asynchronous signaling
o CompletionService

4. Concurrent Streams
 Concurrency in the Streams API
o stream() vs. parallelStream()
o Interface Spliterator
 CompletableFuture
o Supporting Executors using Supplier and Consumer
 Concurrency support for aggregates
o Arrays supporting parallelism
o ConcurrentHashMap improvements

5. Modern Software Patterns
 Object Oriented Development
o Design Patterns – The Catalogue
o MVC – Model View Controller
 General Advice Patterns
o SOLID
o Dependency Injection
o DRY

6. Modern Java Design Patterns
 Modern Java Creational Patterns
o Singleton
o Builder
o Factory Method
 Modern Java Structural Patterns
o Adapter
o Composite
o Case Study – Library using Generic Composite
 Enhanced pattern using Generics
o Decorator
 Modern Java Behavioral Patterns

7. State Machines
 FSM – Finite State Machine
o Supporting fixed number of states
o Separating Context from FSM
o Supporting multiple parallel FSMs
 Implementing FSM using Design Pattern State
o FSM as a shallow inheritance hierarchy
 Abstract top class defines common behavior
 Defining events as Enums
 Derived classes model individual states
 Singleton pattern applied
 Modeling support
o State Table covering all combinations of Events and States
o UML State Diagram, Class Diagram, Object Diagram
 Case Study – Construction Elevator
o Expanding existing FSM with new states/events
 HSM – Hierarchical State Machine
o Defining layers of state machines
o Dependent state machine designed as a pluggable component
 Case study – ATM
o Basic states of the ATM has a connection to dependent FSM
o PINFSM used as an independent component

8. Performance
 General aspects of performance tuning
o Footprint vs. execution speed
 G1 GC – The new default Java Garbage Collector
o Configuration and behavior
 JFR – Java Flight Recorder
o Setting up a JFR session
 JMC – Java Mission Control
o Presenting recordings produced by the JFR

9. Modules
 What are Modules?
o A new packaging level in Java
 Why Modules?
o Packaging limitations in classic Java
o JAR problems
 Modules grammar
o Special keywords reserved for use in module declarations
 module
 open, require, transitive, exports, opens, to uses, provides, with
o Observable modules
 Available for other parts of Java code to use and call
o Internal modules
 Required by module parts but not accessible for other code

10. Building a Library
 Types of libraries
o Broad and Shallow vs. Narrow and Deep
 Library technical design
o Internal Modules
o Observable Modules
 The Library API
o Documentation

11. Java in the Future
 Project Amber
o Small syntax feature enhancements in Java
 Project Valhalla
o Supporting value types in Java
 Project Panama
o Supporting native code calls
 Project Loom
o Introducing Fibers for enhanced concurrency performance

Sign up for this course