Lessons

In this lecture, we examine what a thread deadlock is in Java, why it happens, and which four conditions are required for it. With a practical example using synchronized, we show how to reproduce the problem, then study prevention strategies: a single resource acquisition order, using ReentrantLock.tryLock with a timeout, shortening critical sections, and avoiding unnecessary nested locks. We will show diagnosis via Thread dump and jstack, how to recognise the BLOCKED/ WAITING states, and finish with a checklist and common mistakes.

We examine concurrency anomalies Livelock and Starvation: how they differ from Deadlock, and how they look in code and logs. Java examples are shown: “polite workers” (livelock) and starvation due to priorities and unfair locks. We learn to detect the problem (logging, Thread dump, VisualVM, Java Mission Control) and to prevent it: random delays before retry ( Thread.sleep), non‑blocking algorithms, fair locks via ReentrantLock with the fairness flag ( new ReentrantLock(true)), careful critical sections, and avoiding abuse of setPriority() and synchronized.

In this lecture, we’ll look at why regular collections ( ArrayList, HashMap) are dangerous in a multithreaded environment, and which thread-safe alternatives the java.util.concurrent package provides: ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue, skip-list–based structures, and BlockingQueue. We’ll discuss atomic operations like merge, putIfAbsent, computeIfAbsent, compare them with Collections.synchronizedMap, and cover practical examples and common mistakes (weakly consistent iterators, non-atomic sequences of operations, etc.).

Why the increment i ++ doesn’t work in multithreading, what atomic operations are, and how the java.util.concurrent.atomic package provides them. We break down AtomicInteger and AtomicReference, the methods incrementAndGet(), compareAndSet(...), the internal CAS (Compare-And-Swap) mechanism, as well as when it’s better to choose synchronized and when — LongAdder. Finally — typical pitfalls: compound operations, ABA, and thread safety of nested objects.

How to capture and read a Thread Dump using jstack, VisualVM, and an IDE; recognize thread states ( RUNNABLE, BLOCKED, WAITING) and find deadlocks. We will cover thread monitoring in Java Mission Control and Java Flight Recorder, logging practices (thread names, entering/exiting synchronized), minimizing locks, concurrency testing with CountDownLatch, and a real deadlock case study. Finally — common mistakes and how to avoid them.

In this lecture we unpack the difference between multithreading and parallelism: where responsiveness matters, and where real speed-up across multiple cores matters. We will discuss creating threads via Thread, implementing Runnable, and high-level pools with ExecutorService; look at a simple array-summing example; examine when parallelism helps and when it hurts; and cover typical issues: data races, synchronization with synchronized, deadlocks, and load balancing. We finish with a comparison table and scenario visualizations.

Serious multithreading practice: pass tasks to ExecutorService instead of manually creating a Thread, and manage the pool, the queue, and the lifecycle ( shutdown(), shutdownNow()). We’ll go over the difference between Runnable and Callable<T>, get results via Future and its methods ( get(), isDone(), cancel(...), isCancelled()). We’ll show running multiple tasks, invokeAll/ invokeAny, handling ExecutionException, and common mistakes.

Let’s figure out how to switch a regular data stream to parallel processing in one line—via parallelStream() or .parallel(), what happens under the hood in ForkJoinPool.commonPool(), when parallelism actually speeds up computations (large collections, “heavy” operations), and where it can slow things down. We’ll show examples of filtering, aggregation, sorting, performance measurement, and break down typical mistakes: side effects in forEach, preserving order, choosing collections, and tuning the degree of parallelism.

A practical guide to parallel computation in Java: how the ForkJoinPool task pool and recursive tasks RecursiveTask<T>/ RecursiveAction work, why the work-stealing algorithm is useful, how to split tasks via fork() and merge results with join() inside compute(). We will cover running via pool.invoke(), an example of summing an array and finding a maximum, the role of ForkJoinPool in parallelStream(), as well as typical mistakes and how to avoid them.

A practical guide to parallel programming in Java: when to use ExecutorService, where parallelStream helps, and what tasks need ForkJoinPool. We will discuss thread safety with ConcurrentHashMap/ CopyOnWriteArrayList and atomic classes ( AtomicInteger), performance measurements with System.nanoTime() and JMH, error handling from Future.get() and ForkJoinTask, proper reactions to InterruptedException, as well as logging techniques ( Thread.currentThread().getName()) and testing ( Awaitility). At the end—an instrument selection table and common mistakes.

Breaking down launching and composing asynchronous computations with CompletableFuture: how to start tasks via supplyAsync and runAsync, how the handlers thenApply, thenAccept, thenRun differ, and when to choose their async versions thenApplyAsync/ thenAcceptAsync/ thenRunAsync. We’ll talk about execution threads ( ForkJoinPool or your Executor), result types ( CompletableFuture<T>, CompletableFuture<Void>) and common mistakes: blocking get()/ join(), unhandled errors without exceptionally/ handle/ whenComplete, and also trying to use the result inside thenRun.