CS414
Parallel Programming
Faculty
Bulat Mukhutdinov
Staff Android Engineer at inDrive
Course length
Duration
Total hours
Credits
Language
Course type
Fee for single course
Fee for degree students
Skills you’ll learn
Overview
This course introduces the foundations and practice of parallel programming on modern multi-core systems using the Java Virtual Machine (JVM) ecosystem. Students learn how to design correct and efficient concurrent programmes with Java and Kotlin, covering threads, memory models, synchronisation, atomics, executors, fork/join, parallel streams, coroutines, virtual threads, reactive streams, actor-based systems, and performance analysis.
Learning highlights
- Identify opportunities for parallelism and choose an appropriate concurrency model.
- Write, coordinate, and safely stop threads and asynchronous tasks.
- Apply synchronisation primitives, concurrent collections, and atomic operations correctly.
- Use ExecutorService, CompletableFuture, Fork/Join, and parallel streams for scalable task execution.
- Build asynchronous workflows with Kotlin coroutines, channels, flows, and Java virtual threads.
- Reason about memory visibility, race conditions, deadlocks, and lock-free techniques.
- Profile, test, debug, and optimise concurrent programmes.
Course outline
15 classes
Session 1
Evolution from sequential to parallel computing.
Why parallelism? Moore's Law limitations and multicore era.
Parallelism vs concurrency.
Types of parallelism: data, task, pipeline.
Amdahl's Law and Gustafson's Law.
Overview of parallel architectures (SMP, NUMA, distributed).
Session 2
Process vs thread concepts.
Creating threads (POSIX, Java Thread, Runnable, Callable).
Thread lifecycle and states.
Thread interruption and UncaughtExceptionHandler.
Thread-local storage.
Naming, daemon threads, and thread debugging tools.
Thread creation overhead.
Session 3
Flynn's taxonomy (SISD, SIMD, MISD, MIMD).
Shared memory vs distributed memory systems.
Cache architecture and cache coherence.
False sharing and how to avoid it.
Java Memory Model (JMM) fundamentals.
Happens-before relationships.
Volatile and synchronised semantics.
Session 4
Race conditions and critical sections.
Synchronised keyword and intrinsic locks.
Mutexes and ReentrantLock.
Semaphores and condition variables.
Read-write locks.
Spinlocks vs blocking locks.
Session 5
Deadlock conditions (Coffman conditions).
Deadlock prevention, avoidance, detection.
Livelocks and starvation.
Priority inversion.
Lock ordering strategies.
Session 6
Problems with standard collections in concurrent environment.
ConcurrentHashMap internals.
CopyOnWriteArrayList.
Blocking queues (ArrayBlockingQueue, LinkedBlockingQueue).
Lock-free collections overview.
Performance trade-offs.
Session 7
Atomic operations and CAS (Compare-And-Swap).
Memory ordering and memory barriers.
AtomicInteger, AtomicReference, AtomicStampedReference.
ABA problem and solutions.
Lock-free data structures (stack, queue).
Wait-free algorithms introduction.
Session 8
Executor framework architecture.
Fixed, cached, scheduled, single-thread executors.
Task submission (Runnable, Callable, Future).
CompletableFuture and asynchronous pipelines.
Graceful shutdown strategies.
Custom thread pools configuration.
Session 9
Divide and conquer approach.
ForkJoinPool and work stealing.
RecursiveTask and RecursiveAction.
Parallel patterns: Map, Reduce, Scan (prefix sum).
Parallel sorting algorithms.
Load balancing strategies.
Session 10
Java Streams overview.
Sequential vs parallel streams.
When parallel streams help and when they hurt.
Reduction operations and collectors.
Common pitfalls and performance considerations.
Custom spliterators.
Session 11
Coroutines vs threads: lightweight concurrency.
Suspending functions and continuation.
Coroutine builders (launch, async, runBlocking).
Dispatchers and contexts.
Structured concurrency and scopes.
Channels and flows.
Session 12
Project Loom motivation and goals.
Virtual threads vs platform threads.
Creating and managing virtual threads.
Thread-per-request model revisited.
Structured concurrency with StructuredTaskScope.
Comparison with ExecutorService, CompletableFuture, and Kotlin coroutines.
Migration strategies and pitfalls.
Session 13
Reactive programming motivation: asynchronous and non-blocking.
Reactive Streams specification (Publisher, Subscriber, Subscription).
Project Reactor: Mono and Flux.
Operators (map, flatMap, zip, merge, buffer).
Schedulers and threading model.
Backpressure strategies (buffer, drop, latest, error).
Integration with Spring WebFlux.
Session 14
Shared state vs message passing paradigms.
Actor model concepts: actors, messages, mailboxes.
Akka actors (Java API): creating, sending, receiving.
Actor lifecycle and supervision strategies.
Comparison with threads, executors, and coroutines.
When actors are a good fit and when they are not.
Session 15
Producer-consumer pattern.
Pipeline and fan-out/fan-in.
Barrier and phaser patterns.
Bulkhead pattern (isolation of thread pools).
Rate limiter and throttling.
Circuit breaker.
Choosing the right tool: threads vs executors vs streams vs coroutines vs virtual threads.
Course materials
Books
Media
Prerequisites
Basic proficiency in Kotlin or Java, including familiarity with syntax, data types, functions, classes, and collections.
Understanding of object-oriented programming concepts.
Experience with IntelliJ IDEA or another Kotlin-capable IDE for writing and running code.
Working knowledge of the JVM ecosystem and building tools such as Gradle or Maven is beneficial.
General programming experience (6+ months) to comfortably follow the pace of the course.
Methodology
The course combines lectures with hands-on programming practice.
* Students complete 15 programming assignments in GitHub Classroom, typically started in class and finished at home.
* Short quizzes check understanding of the previous lecture, and active participation is assessed during class.
* The course concludes with a final written test covering the full syllabus.
Grading
With over a decade of experience in the IT industry, Bulat brings a wealth of expertise primarily as an architect Android developer. His journey commenced as a Java backend developer, allowing him to grasp the intricacies of foundational programming. Over the years, he swiftly transitioned to the dynamic realm of mobile application development. Proficient in Android, iOS, and hybrid technologies, the instructor has successfully contributed to the creation of diverse and innovative mobile applications.
Currently serving as a Staff Android Engineer at inDrive, which works in 46 countries and 749 cities, Bulat plays a pivotal role in shaping and implementing cutting-edge solutions. This vast and varied experience uniquely positions our instructor to offer valuable insights and practical knowledge to students seeking to excel in the fields of mobile development and software architecture.
See full profileApply for this course
Parallel Programming
by Bulat Mukhutdinov
Total hours
45 Hours
Dates
Jun 29 - Jul 17, 2026
Fee for single course
€1500
Fee for degree students
€750
How to secure your spot
Complete the form below to kickstart your application
Schedule your Harbour.Space interview
If successful, get ready to join us on campus
FAQ
Will I receive a certificate after completion?
Yes. Upon completion of the course, you will receive a certificate signed by the director of the program your course belonged to.
Do I need a visa?
This depends on your case. Please check with the Spanish or Thai consulate in your country of residence about visa requirements. We will do our part to provide you with the necessary documents, such as the Certificate of Enrollment.
Can I get a discount?
Yes. The easiest way to enroll in a course at a discounted price is to register for multiple courses. Registering for multiple courses will reduce the cost per individual course. Please ask the Admissions Office for more information about the other kinds of discounts we offer and what you can do to receive one.