Multithreading & Concurrency

What you will be able to do

• Create and control threads and explain the life cycle of a thread
• Find race conditions and fix them with synchronized, locks or atomics
• Run tasks with executors, thread pools and virtual threads
• Use concurrent collections and synchronizers instead of building your own
• Chain asynchronous work with CompletableFuture
• Recognise deadlocks and other classic concurrency bugs and fix them

What it will cover

1. 10.1Thread Basics

   What threads are, why programs use them and how to start and wait for them.

   Show 5 topics
   • Processes, threads and why concurrency is useful
   • Thread and Runnable
   • start() versus run()
   • sleep, join and interrupt
   • Thread states and daemon threads

2. 10.2Race Conditions & synchronized

   See shared data go wrong with two threads and fix it with locking.

   Show 5 topics
   • Why count++ is not safe
   • Check-then-act bugs
   • synchronized methods and blocks
   • Which object is the lock
   • Keeping locked sections small

3. 10.3Visibility & volatile

   Why one thread may not see another thread's change, and the rules that guarantee it does.

   Show 5 topics
   • The visibility problem with a stop flag
   • volatile and what it does not fix
   • Happens-before in plain words
   • Immutable objects as a safe way to share data
   • ThreadLocal for per-thread data

4. 10.4Thread Coordination

   Make threads wait for each other, from wait and notify to blocking queues.

   Show 4 topics
   • wait, notify and notifyAll
   • The producer-consumer problem
   • BlockingQueue as the simpler solution
   • Stopping worker threads cleanly

5. 10.5Locks & Atomic Variables

   More flexible tools than synchronized, and lock-free counters.

   Show 5 topics
   • ReentrantLock and try/finally unlock
   • tryLock with a timeout
   • ReadWriteLock for read-heavy data
   • AtomicInteger, AtomicLong and compare-and-set
   • LongAdder for busy counters

6. 10.6Executors & Thread Pools

   Hand tasks to a pool instead of creating threads by hand.

   Show 6 topics
   • ExecutorService and fixed thread pools
   • Callable and Future
   • invokeAll and scheduled executors
   • Shutting down a pool correctly
   • Choosing a pool size
   • Virtual threads in Java 21

7. 10.7Concurrent Collections

   Thread-safe collections and why wrapping a normal collection is often not enough.

   Show 4 topics
   • ConcurrentHashMap and its atomic methods
   • Collections.synchronizedList and its limits
   • CopyOnWriteArrayList
   • ArrayBlockingQueue and LinkedBlockingQueue

8. 10.8Synchronizers

   Ready-made tools to make groups of threads wait or limit how many run at once.

   Show 4 topics
   • CountDownLatch
   • CyclicBarrier
   • Semaphore for limiting access
   • Choosing the right synchronizer

9. 10.9CompletableFuture

   Run work in the background and combine results without blocking.

   Show 5 topics
   • supplyAsync and runAsync
   • thenApply, thenAccept and thenCompose
   • Combining tasks with thenCombine and allOf
   • Handling errors with exceptionally and handle
   • Using your own executor

10. 10.10Classic Concurrency Bugs

    Deadlocks, livelocks and other bugs that only show up sometimes, and how to find and fix them.

    Show 5 topics
    • Deadlock and lock ordering
    • Livelock and starvation
    • Lost updates and broken invariants
    • Reading a thread dump
    • Testing concurrent code honestly

11. 10.11Concurrency Mini Projects

    Small programs that put threads, pools and concurrent collections to work.

    Show 4 topics
    • Parallel word counter over many files
    • Bank transfers without deadlock
    • Order processing with producer and consumer threads
    • Price fetcher that combines results with CompletableFuture