Milliseid andmevoogude töö omadusi pakub Kotlin…

Kotlin offers built-in support for coroutines for asynchronous, non-blocking work, providing a lighter alternative to OS threads.

Features of working with data streams via coroutines:

Lightweight: Coroutines are not tied to OS threads 1:1. One coroutine consumes significantly fewer resources.
Structured concurrency: Hierarchical structure of coroutine creation (parent-child) simplifies task cancellation and error handling.
Suspending functions: The suspend keyword allows pausing function execution without blocking the thread, then resuming.

Channels: Provide a safe way to communicate between coroutines by passing data.

// Example of using Channel
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

fun main() = runBlocking {
    val channel = Channel<Int>()
    launch { // Sender coroutine
        for (x in 1..5) channel.send(x * x)
        channel.close() // Close channel after sending
    }
    // Receiver coroutine
    for (y in channel) {
        println(y)
    }
    println("Done!")
}

Flow (Data streams): Represent cold asynchronous data streams that can emit multiple values. Similar to RxJava Observable, but better integrated with coroutines.

// Example of using Flow
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    flow { // Creating Flow
        for (i in 1..3) {
            delay(100) // Simulate async work
            emit(i) // Emit value
        }
    }.collect { value -> // Collect values
        println(value)
    }
}

Dispatchers: Define thread pools where coroutines will run.
- Dispatchers.Default: For heavy computational tasks.
- Dispatchers.IO: For I/O operations.
- Dispatchers.Main: For UI updates (available on platforms with UI loop).
- Dispatchers.Unconfined: Not limited to any specific thread.
Selectors (Select): Allow waiting for multiple asynchronous operations and executing an action upon the first completion.

Of course, in Kotlin, you can also work with traditional Java threads (java.lang.Thread), but coroutines are the preferred approach for asynchronous and concurrent data processing in most cases.

Milliseid andmevoogude töö omadusi pakub Kotlin programmeerimiskeel?