Lære Limitations of Threads | Concurrency Basics in Kotlin

Sveip for å vise menyen

When you work with concurrency in Kotlin, using threads directly might seem straightforward at first, but several key limitations quickly become apparent. Here are the main drawbacks you will encounter:

High resource usage: Each thread consumes a significant amount of memory and system resources, which can lead to performance degradation if too many threads are created;
Increased complexity: Managing thread lifecycles, synchronization, and communication between threads adds substantial complexity to your code;
Error-proneness: It is easy to introduce subtle bugs such as race conditions, deadlocks, or resource leaks when dealing with low-level thread management.

These issues make it challenging to build scalable, maintainable, and reliable concurrent applications using only threads.

Main.kt


              1234567891011121314151617181920212223242526272829
            
package com.example

fun main() {
    val sharedCounter = Counter()

    val threads = List(100) { index ->
        Thread {
            repeat(1000) {
                sharedCounter.increment()
            }
            if (index == 0) {
                println("Thread 0 finished")
            }
        }
    }

    threads.forEach { it.start() }
    threads.forEach { it.join() }

    println("Final counter value: ${sharedCounter.value}")
}

class Counter {
    var value = 0

    fun increment() {
        value++ // Not thread-safe: potential race condition
    }
}

In the example above, you create 100 threads, each incrementing a shared counter 1,000 times. This approach highlights several problems. First, creating a large number of threads can exhaust system resources, leading to sluggish performance or even application crashes. Second, the increment function is not thread-safe, so multiple threads may try to update the counter simultaneously, causing a race condition. As a result, the final counter value may be less than expected, even though each thread performed the correct number of increments. These issues make it clear why higher-level abstractions, such as coroutines, are needed to simplify concurrency and avoid common pitfalls.

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 4

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Seksjon 1. Kapittel 4