CS414
Multithreading Programming
Faculty
Bulat Mukhutdinov
Principal 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
In today’s world of multi-core processors and distributed systems, the ability to write efficient parallel and concurrent code is no longer optional — it is essential. This comprehensive course teaches you how to harness the full power of modern hardware using Kotlin’s advanced concurrency features, particularly coroutines, which have transformed asynchronous programming on the JVM.
Learning highlights
- Performance at Scale: Learn to build applications that can handle thousands or millions of concurrent operations efficiently. Modern applications demand responsiveness and high throughput — whether you are building backend services, Android apps, or data-processing pipelines.
- Master Kotlin Coroutines: Coroutines are Kotlin’s groundbreaking approach to concurrency, offering lightweight alternatives to threads with elegant syntax. This course provides deep, practical knowledge of coroutines — from the basics to advanced patterns used in production systems.
- Solve Real Problems: Stop writing sequential code that underutilises your hardware. Learn to identify parallelisable workloads, avoid common concurrency pitfalls such as race conditions and deadlocks, and write thread-safe code with confidence.
Course outline
15 classes
Session 1
Concurrency vs parallelism, hardware perspective (multi-core, caches, memory hierarchy), and JVM Memory Model.
Common challenges: race conditions, deadlocks, livelocks, and Amdahl's/Gustafson's Laws.
JVM threading model and its implications for parallel programming.
Session 2
JVM thread lifecycle, synchronisation primitives (@Volatile, synchronized, ReentrantLock, ReadWriteLock, StampedLock).
Thread pools and executors: ForkJoinPool, ThreadPoolExecutor, ThreadLocal variables.
Common pitfalls: lost updates, ABA problem, priority inversion, and deadlock.
Analysis.
Session 3
Coroutines vs threads: advantages, suspending functions, and the suspend keyword.
Coroutine builders (launch, async, runBlocking), CoroutineScope and CoroutineContext.
Structured concurrency and basic coroutine cancellation.
Session 4
CoroutineContext deep dive, Dispatchers (Default, IO, Main, Unconfined) and when to use each.
Creating custom dispatchers, context inheritance and composition with withContext.
Performance implications of dispatcher choices.
Session 5
Structured concurrency principles, parent-child relationships, and Job hierarchy.
CoroutineScope types (GlobalScope, MainScope, custom), SupervisorJob and exception handling.
Lifecycle-aware scopes and cancellation propagation best practices.
Session 6
Using async and await effectively, parallel decomposition patterns.
Deferred values, lazy execution, and combining multiple async operations.
Error handling, timeouts, and retry mechanisms in async code.
Session 7
Channels for coroutine communication: types (Rendezvous, Buffered, Unlimited, Conflated).
Producer-consumer, fan-out, fan-in, and pipeline patterns with channels.
Channel closing, iteration, and proper resource management.
Session 8
Flow and cold streams: builders (flow, flowOf, asFlow) and operators (map, filter, transform, reduce).
Terminal operators (collect, toList, first, single), Flow context and dispatchers.
Flow cancellation, exception handling, backpressure, and buffering strategies.
Session 9
Flattening operators (flatMapConcat, flatMapMerge, flatMapLatest) and combining flows (zip, combine, merge).
StateFlow and SharedFlow: hot vs cold flows, lifecycle and sharing strategies.
Testing flows and performance optimisation techniques.
Session 10
Atomic operations, CAS, lock-free and wait-free algorithms, ABA problem solutions.
Memory ordering (acquire-release semantics), false sharing, cache line padding.
Concurrent data structures, Mutex/Semaphore in coroutines, and Software Transactional Memory concepts.
Session 11
Parallel collection processing with coroutines: map, flatMap, chunking and batch strategies.
Parallel streams in Kotlin/JVM, work-stealing algorithms, and choosing concurrency level.
Memory considerations and performance optimisation in parallel processing.
Session 12
Exception propagation in coroutines, CoroutineExceptionHandler, SupervisorJob vs regular Job.
Error channels, error flows, and recovering from failures in suspending functions.
Retry and fallback strategies, best practices for robust concurrent code.
Session 13
Unit testing coroutines: kotlinx-coroutines-test, TestCoroutineDispatcher, TestCoroutineScope.
Testing flows with turbines, virtual time control, and testing race conditions.
Integration testing for concurrent systems, common patterns and anti-patterns.
Session 14
Profiling coroutine applications, identifying bottlenecks, CPU vs I/O bound optimisation.
Reducing context switching overhead, memory management, and coroutine debugging tools.
Monitoring, metrics for production systems, and common performance anti-patterns.
Session 15
Building scalable web services with Ktor, reactive systems, integration with Project Reactor/RxJava.
Kotlin Multiplatform concurrency, Project Loom/Virtual Threads, distributed concurrency patterns.
Rate limiting, circuit breaker patterns, observability, and production deployment strategies.
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
Weekly programming assignments (self-study exercises).
Mid-term project (after Lecture 8).
Final project (comprehensive concurrent application).
Code reviews and best practices evaluation.
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 Principal 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 field of mobile development, and software architecture.
See full profileApply for this course
Multithreading 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.