C++
    RELIABLE C++
    EFFECTIVE STL
    TEMPLATES
    IOSTREAMS
    C++ INTRO   
 

" Writing correct programs is hard; writing correct concurrent programs is harder.  There are simply more things that can go wrong in a concurrent program than in a sequential one. "  (Brian Goetz)

Today, even the smallest computing devices run on at least two or four processors; server software is deployed to hardware with 8 or 16 cores, and the number of processors on each chip will continue to increase in the years to come. While we handle a couple or a few dozens of cores today, we will face the challenge of dealing with hundreds of cores in the future. As a result, single-threaded programs are a fossile of the past.  Concurrent Java programs with multiple threads are the norm and the expectations regarding performance and scalability are rising.

Not only are concurrent Java programs required to run in a predictible, stable and reliable fashion in a multi-core or multi-cpu environment, in addition concurrent Java programs are required to exhibit excellent runtime performance and scalabilty. Ideally they should adapt easily and automatically to increasingly powerful multi-processor hardware.

To meet these goals, Java programs must be thoughtfully engineered to run across multiple cores- The most common method Java programmers have for doing that is keeping track of individual threads and synchronizing access to shared data by means of locks.  Consequently, the seminar provides insights into management of multiple thread - individually or by means of various types of thread pools.  The course also discusses at length the traditional shared mutable state concurrency, i.e., synchronization via locks and thread safety, along with its issues such as deadlocks, starvation, etc.

The traditional synchronization via locks introduces various performance impediments.  For this reason, less expensive alternatives need to be considered; they are available via volatile and atomic variables.  In order to enable participants to optimize the performance of critical operations, the seminar covers the Java memory model and the guarantees it provides for volatile, final, and atomic variables, which are needed for developing lock-free algorithms. 

Recent additions to the JDK / JVM offer abstractions for modern concurrent programming styles beyond classic threads and thead pools: 

In essence, this is the most comprehensive seminar on Java concurrency.  It covers every aspect of concurrent programming in Java relevant to practicing Java programmers - from the fundamental problem of race conditions to the principles of lock-free programming.

The course is for Java programmers who intend to build concurrent applications for multi-core or multi-cpu platforms.

The most comprehensive and up-to-date Java Concurrency seminar world-wide. 

While the excellent book "Java Concurrency in Practice" by Brian Goetz is recommended reading, the course not tied to the book.  The seminar existed long before "Java Concurrency in Practice"  was written, covers all of the book content, and goes beyond it.  Different from the book and in addition to it, the seminar provides in-depth coverage of the Java memory model (including hands-on labs) and explains the latest JDK concurrency extensions such as the fork-join framework, StampedLock, @Contended,  CompletableFuture (all including hands-on labs and performance benchmarks), virtual threads, and structured concurrency.
 

OBJECTIVES

	Understand concurrency control issues in general
	Know the instruments available in Java
	Avoid common errors and pitfalls
	Understand concurrency control idioms

The course is designed by Klaus Kreft & Angelika Langer and backed by years of experience in teaching and more than a decade of practical experience in industrial software development both in C++ and Java.
Angelika Langer is a freelance trainer/consultant in the area of software development in C++ and Java, author of language reference material such as the Java Generics FAQs [ ], the Lambdas/Streams Tutorial & Reference  [ ], and countless articles on C++ and Java topics [ ]. 
Klaus Kreft is a senior consultant for more than 30 years and has served as the lead architect and performance expert on several successful industry projects. He has been working in Java since its advent in 1995. 
Both are recognized speakers at OO and Java conferences and author of numerous articles on C++ and Java topics in various computer magazines worldwide. Together they write a column for the German Java magazine JavaMagazin  [ ] and are authors of the  books "Standard C++ IOStreams and Locales" (2000) [ ] and "Java Core Programmierung" (2011) [ ], the Online FAQ on Java Generics [ ], and the Lambdas/Streams Tutorial & Reference  [ ].

• Synchronization Basics
• Thread Safety
• Thread Creation

• Design Issues: Shared Mutable State & Synchronization 
• Synchronization
• Implicit and Explicit Locks
• Read-Write-Lock & Stamped Lock
• State-Dependent Operations
• Signals & Conditions
• Synchronizers 
• Blocking Queues & Deques
• Semaphore & CountDownLatch
• Barrier & Phaser
• Collections
• Synchronized Collections
• Concurrent Collections
• Thread-Local Memory
• Atomic Scalars & Accumulators

• Atomic Invariant Checks
• Test for Liveness & Blocking State
• Test for Thread Safety & Race Conditions
• Tools, Harnesses, Analyzers

• Design Issues: 
• Task Execution, Threads & Pools
• Platform Threads
• States, Groups, Priorities
• Thread Interruption
• Threads & Exceptions
• Thread Pool Executor
• Basics & Setup
• Completion Service
• Scheduled Tasks
• Configuration
• Shutdown
• Customization
• Fork-Join-Framework
• Recursive Tasks
• Principles & Basic Usage
• Configuration
• Managed Blocker
• Internals & Performance
• Completable Future
• Asynchronous Result Retrieval
• Reactive Fluent Programming
• Virtual Threads
• Synchronous Thread-Per-Task Programming
• Scheduler & Continuation
• Structured Concurrency

• Memory Effects of Volatile Variables
• Double Checked Locking
• Initialization Safety of Final Fields
• Atomic References
• Lock-Free Programming