Deep Kotlin tutorial covering parallelism, concurrency, CPU cores, overlapping work with examples, diagram, mistakes, and interview answers.

Parallelism vs Concurrency

What is Parallelism vs Concurrency?

Parallelism vs Concurrency is an important Kotlin topic from 2.1 Concurrency Fundamentals. In this lesson we focus only on the concepts that belong together: parallelism, concurrency, CPU cores, overlapping work, scheduling. This keeps the lesson deep enough for interviews but not mixed with unrelated ideas.

Why students should learn it

• Understand Parallelism vs Concurrency in simple language
• Use parallelism in real Kotlin or Android code
• Explain Parallelism vs Concurrency in interviews with examples and trade-offs

How it works

Parallelism vs Concurrency: parallelism, concurrency, CPU cores, overlapping work, scheduling works at the operating system and JVM level, below coroutines. A process is an isolated running program with its own memory, a thread is a unit of execution inside a process that shares memory with other threads, and concurrency means multiple tasks make progress over the same time window - which is not automatically the same as parallelism, where tasks run at the exact same instant on separate cores.

1. Identify what problem Parallelism vs Concurrency: parallelism, concurrency, CPU cores, overlapping work, scheduling solves.
2. Write the smallest Kotlin snippet that demonstrates it.
3. Add one Android or JVM use case where it matters.
4. Compare it with a similar concept so the difference is clear.
5. Finish by naming one common mistake and the safer alternative.

Interview tip: keep the answer simple first, then add example, trade-off, and mistake.

Types / Classification

• parallelism: core concept in this lesson
• concurrency: core concept in this lesson
• CPU cores: core concept in this lesson
• overlapping work: core concept in this lesson
• scheduling: core concept in this lesson
• Process: isolated running program with its own memory
• Thread: unit of execution inside a process, sharing memory
• Concurrency: multiple tasks make progress by interleaving

Important differences

Diagram

flowchart TD
A["2.1 Concurrency Fundamentals"] --> B["Parallelism vs Concurrency"]
B --> C["Why it exists"]
C --> D["How it works in Kotlin"]
D --> E["Android or JVM example"]
E --> F["Mistakes and interview answer"]

Examples

Unsynchronized counter (race condition)

var counter = 0
val threads = List(100) { Thread { counter++ } }
threads.forEach { it.start() }
threads.forEach { it.join() }
// counter is often less than 100 here

Fixing it with synchronization

val lock = Any()
var counter = 0
fun increment() {
synchronized(lock) { counter++ }
}

When to use it

Use it when: Use these concepts when multiple parts of an app touch the same mutable state at the same time, such as a shared cache updated from more than one coroutine.

Avoid it when: Avoid adding synchronization where state is already confined to a single thread or coroutine - it only adds complexity.

Common mistakes

• Assuming a background thread is automatically safe just because it 'feels fast' on a good device
• Sharing mutable state across threads without any synchronization
• Confusing concurrency with parallelism when explaining performance
• Adding synchronized blocks everywhere out of fear, even around state only one thread touches
• Not distinguishing a race condition from a deadlock in an interview answer

Interview questions

Read each answer in four parts: simple answer, code example, trade-off, and common mistake.

var counter = 0
val threads = List(100) { Thread { counter++ } }
threads.forEach { it.start() }
threads.forEach { it.join() }
// counter is often less than 100 here

val lock = Any()
var counter = 0
fun increment() {
synchronized(lock) { counter++ }
}

var counter = 0
val threads = List(100) { Thread { counter++ } }
threads.forEach { it.start() }
threads.forEach { it.join() }
// counter is often less than 100 here

var counter = 0
val threads = List(100) { Thread { counter++ } }
threads.forEach { it.start() }
threads.forEach { it.join() }
// counter is often less than 100 here

val lock = Any()
var counter = 0
fun increment() {
synchronized(lock) { counter++ }
}

Practice task

Write one Kotlin example for Parallelism vs Concurrency. Then explain it using: what is it, how it works, where it is used, mistake to avoid, and one interview answer.