The program and course materials "Multicore programming in Java"

Good day.
My name is Golovach Ivan, I will conduct a second course-webinar “Multicore programming in Java” for the second time . This article offers a course program and the most useful threading references in Java for review.

I also teach Scala for Java Developers on the udemy.com online education platform (equivalent to Coursera / EdX).

Briefly about the course: starts on September 1, is conducted in webinar mode twice a week (Monday + Thursday) from 7 to 10 pm (Moscow time), consists of 16 lectures of 2.5 hours each (= 40 lecture hours), calculated on Java Middle.
')
1. Module # 1: Between hardware and New JMM
1.1 Module program
1.2 Literature to module
2. Module # 2: java.util.concurrent
2.1 Module program
2.2 Literature to module
3. Module # 3: Fork / Join Framework + Parallel Streams
3.1 Module program
3.2 Literature to module
4. Module # 4: “Non-classical architectures”
4.1 Module program
4.2 Literature to module

Module # 1: Between hardware and New JMM

Module program

• "Iron"
  
  • Architecture of modern processors, caches
  • Memory barriers, read / write reordering, cache coherence protocols
• “Mathematics” / Java Memory Model
  
  • New JMM - description "on the fingers"
  • What guarantees give Thread.start () / join (), volatile, final, CAS, lazySet, weakCompareAndSet, classes from juc
  • New JMM Formal Specification: happens-before edge, commitment protocol
• Primitives / constructions
  
  • Double checked locking (broken), safe publishing
  • synchronized + Object.wait () / notify () / notifyAll () - how to use, what guarantees, as implemented in HotSpot
  • We sell our own: Dekker's algorithm, Peterson's algorithm, Lamport Bakery algotithm

Literature to the module

• Literature on "iron" (for start)
  • Martin Thompson, "Mechanical Sympathy"
  • Ruslan Cheremin, "Working Notes"
• Literature on "iron" (for serious people)
  • "A Primer on Memory Consistency and Cache Coherence" - a two-hundred-page tutorial on the implementation of cache consistency in processors
  • "What Every Programmer Should Know About Memory" - a hundred-page manual on the memory device (registers, caches, conformance, DMA, atomic)
  • "The Architecture of the Nehalem Processor and the Nehalem-EP SMP Platforms" - well, or just a description of the modern Intel Nehalem.
• Java Memory Model Literature (for start)
  • JSR 133 (Java Memory Model) FAQ + translation - short review.
  • Doug Lea's JSR-133 cookbook - how JMM is implemented by hardware compilers.
  • Brian Goetz, “Double-checked locking: Clever, but broken”
  • The "Double-Checked Locking is Broken" Declaration
• Java Memory Model Literature (for serious people)
  • The Java Memory Model is a formal and accurate description of the New JMM.

Module # 2: java.util.concurrent

Module program

• Multithreaded collections
  
  • BlockingQueue's
  • ConcurrentMap-s: ConcurrentHashMap, ConcurrentSkipListMap
  • Copy-on-write structures: CopyOnWriteArrayList, CopyOnWriteArraySet
• “Synchronizers”
  
  • Lock, Condition, ReentrantLock, ReentrantReadWriteLock, Semaphore
  • CountDownLatch, CyclicBarrier, Exchanger, Phaser
• Thread pool + future
  
  • Executors, ExecutorService, ThreadPoolExecutor, ScheduledExecutorService, ScheduledThreadPoolExecutor
  • Callable, Future, what is missing jucFuture
• Core juc: AbstractQueuedSynchronizer + LockSupport
  
  • Inside jucAQS
  • We build our primitives on jucAQS + LockSupport

Literature to the module

• Literature on java.util.concurrent (for start)
  • The Java Tutorial: Concurrency
  • Package java.util.concurrent Description
  • javadoc: java.util.concurrent.locks.Lock
  • javadoc: java.util.concurrent.locks.Condition
  • javadoc: java.util.concurrent.Executor
  • java.util.concurrent.ExecutorService
  • javadoc: java.util.concurrent.CountDownLatch
  • java.util.concurrent.CyclicBarrier
  • java.util.concurrent.Exchanger
  • java.util.concurrent.Phaser
  • java.util.concurrent.Semaphore
• Literature on java.util.concurrent (for serious people)
  • Brian Goetz and others, “Java Concurrency in Practice”
  • Doug Lea, "The java.util.concurrent Synchronizer Framework"
  • javadoc: java.util.concurrent.locks.LockSupport
  • javadoc: java.util.concurrent.locks.AbstractQueuedSynchronizer

Module # 3: Fork / Join Framework + Parallel Streams

Module program

• Fork / Join Framework
  
  • Solve problems in the style of recursive parallelism
  • Idioms and typical tasks
  • Fork / Join Framework - that "under the hood"
• Parallel streams
  
  • Java 8 - working with data through java.util.Stream
  • java.util.Stream.parallel () - that "under the hood"

Literature to the module

• Fork / Join Framework Literature (for start)
  • Fork / Join Framework in Java 7
• Fork / Join Framework Literature (for serious people)
  • Doug Lea, “A Java Fork / Join Framework” —The author of F / J talks about his brainchild.
  • java.util.concurrent.CountedCompleter
• Literature on Parallel Streams (for start)
  • javadoc: java.util.stream.Stream
  • Package: java.util.stream
  • java.util.Spliterator
  • State of the Lambda
  • State of the Lambda: Libraries Edition
  • Java 8 Lambdas: Pragmatic Functional Programming

Module # 4: “Non-Classical Architectures”

Module program

• Non-blocking algorithm
  
  • Package jucatomic: AtomicXXX, AtomicXXXArray, AtomicXXXFieldUpdater, AtomicStampedReference, AtomicMarkableReference
  • Classification: blocking, non-blocking, lock-free, wait-free, obstruction free
  • Non-blocking implementations of the main data structures: stack, queue, deque, hashtable, treemap
• Message-Based Architecture (Akka)
  
  • Akka Library
  • Basic patterns, typical architectures
  • Pros and cons of message-based architectures
• Software Transactional Memory (STM)
  
  • Library clojure.lang. *
  • Pros and cons of transactional memory architectures
• Persistent Data Structures
  
  • Pros and cons of persistent data structures
  • Persistent implementations of underlying data structures
  • Pcollections library

Literature to the module

• Literature on non-blocking algorithms (for start)
  
  • Package java.util.concurrent.atomic
  • wiki: Non-blocking algorithm
  • wiki: ABA problem
  • wiki: Compare-and-swap
  
  
• Literature on non-blocking algorithms (for serious people)
  • Maurice Herlihy, "Wait-Free Synchronization"
  
  
• Literature on the basis of messaging (for start)
  • wiki: Actor model
  • Akka: Terminology, Concepts
  • Akka: Actor Systems
  • Akka: What is an Actor?
  • Akka: Supervision and Monitoring
  • Akka: Actor References, Paths and Addresses
  • Akka: Akka and the Java Memory Model
  
  
• Message-Based Architecture Literature (for serious people)
  • Jamie Allen, "Effective Akka"
  
  
• Persistent Data Structures literature (for start)
  • wiki: Persistent data structure
  • pcollections.org
  
  
• Persistent Data Structures Literature (for serious people)
  • Chris Okasaki, "Purely Functional Data Structures"
  
  

General literature

In the previous section, I looked at references on specific topics of specific modules, however, there are three very good books that are literally worth reading in their entirety. I didn’t want to “pull them into chapters,” so they

• Brian Goetz and others, “Java Concurrency in Practice”
• Doug Lea, “Concurrent Programming in Java: Design Principles and Pattern”
• Maurice Herlihy, Nir Shavit, “The Art of Multiprocessor Programming”

Contacts

Course fee
- if paid before August 9 - $ 375
- if paid before August 16 - $ 400
- if paid before August 23 - $ 425
- if paid before August 30 - $ 450

I do Java online training (here are the programming courses ) and publish some of the training materials as part of the reworking of the Java Core course . You can see videos of lectures in the audience on the youtube channel , perhaps the video of the channel is better organized in this article .

I will be happy to answer all questions with the following contacts (or in the comments)
skype: GolovachCourses
email: GolovachCourses@gmail.com