Deep Kotlin tutorial covering process, thread, task, concurrency with examples, diagram, mistakes, and interview answers.

Processes, Threads, Tasks, and Concurrency

What is Processes, Threads, Tasks, and Concurrency?

Processes, Threads, Tasks, and Concurrency is an important Kotlin topic from 2.1 Concurrency Fundamentals. In this lesson we focus only on the concepts that belong together: process, thread, task, concurrency, Android main thread. This keeps the lesson deep enough for interviews but not mixed with unrelated ideas.

Why students should learn it

• Understand Processes, Threads, Tasks, and Concurrency in simple language
• Use process in real Kotlin or Android code
• Explain Processes, Threads, Tasks, and Concurrency in interviews with examples and trade-offs

How it works

Processes, Threads, Tasks, and Concurrency: process, thread, task, concurrency, Android main thread 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 Processes, Threads, Tasks, and Concurrency: process, thread, task, concurrency, Android main thread 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

• process: core concept in this lesson
• thread: core concept in this lesson
• task: core concept in this lesson
• concurrency: core concept in this lesson
• Android main thread: 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["Processes, Threads, Tasks, and 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: Apply this directly in Android app code - ViewModels, Fragments/Activities, and Compose screens are where these patterns show up daily.

Avoid it when: Avoid copying a pattern from a plain Kotlin script into Android code without first checking its lifecycle implications.

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 Processes, Threads, Tasks, and Concurrency. Then explain it using: what is it, how it works, where it is used, mistake to avoid, and one interview answer.