In this MSc course, you learn how to write correct and efficient concurrent and parallel software, primarily using Java, on standard shared-memory multicore hardware. The course covers basic mechanisms such as threads, locks and shared memory as well as more advanced mechanisms such as parallel streams for bulk data, transactional memory, message passing, and lock-free data structures with compare-and-swap. It covers concepts such as atomicity, safety, liveness and deadlock. It covers how to measure and understand the performance and scalability of parallel programs. It covers methods to find bugs in concurrent programs.
For exercises and more information, see the course LearnIT site (restricted access). For formal rules, see the official course description.
The course is taught by Thomas Dybdahl Ahle and designed together with Peter Sestoft, Riko Jacob and Claus Brabrand at the IT University of Copenhagen. Teaching assistants are Jorgel Këci, Jon Voigt Tøttrup and Amund Ranheim Lome who help with exercises and approve (or not) the mandatory hand-ins.
Concurrent and parallel programming, why, what is so hard. Threads and locks in Java, shared mutable memory, mutual exclusion, visibility, volatile fields, atomic operations, avoiding sharing (thread confinement, stack confinement), immutability, final, safe publication.
Materials: Goetz chapters 1, 2, 3; Sutter paper; McKenney chapter 2; Bloch item 66
Handin at LearnIT.
Designing thread-safe classes. Monitor pattern. Concurrent collections. Documenting thread-safety.
Materials: Goetz chapters 4, 5; Bloch item 15; jcip-annotations.jar
Handin at LearnIT.
Materials: Sestoft: Microbenchmarks and supporting Java code; Optional: McKenney chapter 3, (The Art of) (Java) Benchmarking
Handin at LearnIT.
Java 8 parallel streams for bulk data and parallel array prefix operations. Functional interfaces, lambda expressions, method reference expressions.
Materials: Sestoft: Java Precisely 3rd edition sections 11.13, 11.14, 23, 24, 25; get draft on LearnIT and associated example code. Also File with English words.
Handin at LearnIT.
Tasks and the Java executor framework. Concurrent pipelines, wait() and notifyAll().
Materials: Goetz chapters 5.3, 6, 8; Bloch items 68, 69
Handin at LearnIT.
No exercises or lecture this week.
Concurrent hash maps: performance and scalability case study.
Materials: Goetz chapter 11, 13.5
Handin at LearnIT.
No exercises or lecture this week.
Testing concurrent programs.
Materials: Goetz chapter 12; Herlihy and Shavit chapter 3
Handin at LearnIT.
Transactional memory with Multiverse: Multiverse API Javadoc and file multiverse-core-0.7.0.jar.
Materials: Harris et al 2008 paper; Herlihy and Shavit sections 18.1-18.2; Cascaval et al 2008 paper; Eidenbenz, Wattenhofer 2011 paper;
Handin at LearnIT.
Notice: Lecture will be posted as video thursday afternoon. There won't be anyone in the auditorium in the morning; Description: Optimistic concurrency, lock-free data structures, Treiber stack, compare-and-swap. Consensus number.
Materials: Goetz chapter 15; Herlihy and Shavit sections 5.1-5.2
Handin at LearnIT.
The Michael and Scott queue, progress concepts, Union Find, work-stealing queues.
Materials: Michael and Scott paper and Chase and Lev paper sections 1, 2 and 5
Handin at LearnIT.
Message passing (no mutable shared memory), Erlang, Java+Akka.
Materials: Just the slides
Handin at LearnIT.
~/lib/jcip-annotations.jar, add import javax.annotation.concurrent.GuardedBy; to your Java source files, and mention the jar file on the classpath when compiling Java files, as in javac -cp ~/lib/jcip-annotaitons.jar *.java