Dispatchers — βασικές έννοιες, τύποι dispatchers και πώς λειτουργούν

Τι είναι οι Dispatchers;

Dispatchers — υλοποιήσεις της διεπαφής CoroutineDispatcher, που είναι στοιχεία του CoroutineContext. Καθορίζουν σε ποιο νήμα ή δεξαμενή νημάτων θα εκτελεστεί το coroutine. Κατά τη δημιουργία coroutine μέσω launch ή async, ο dispatcher μπορεί να μεταβιβαστεί ως πρώτη παράμετρος: launch(Dispatchers.IO) { ... }. Εάν δεν καθοριστεί dispatcher, κληρονομείται από το εξωτερικό CoroutineScope.

Η Kotlin παρέχει τέσσερις ενσωματωμένους dispatchers: Main, IO, Default, Unconfined. Κάθε dispatcher χρησιμοποιεί τη δική του δεξαμενή νημάτων, βελτιστοποιημένη για συγκεκριμένο τύπο λειτουργίας. Η σωστή επιλογή dispatcher καθορίζει την απόδοση της εφαρμογής: λανθασμένη επιλογή οδηγεί σε καθυστερήσεις διεπαφής, αδράνεια πυρήνων CPU ή αναποτελεσματική χρήση νημάτων.

Dispatchers.Main: νήμα UI

Dispatchers.Main — dispatcher που εκτελεί coroutines στο κύριο νήμα Android. Προορίζεται για λειτουργίες που σχετίζονται με τη διεπαφή: ενημέρωση TextView, κλήση notifyDataSetChanged, εργασία με LiveData και StateFlow. Στο Android, αυτός ο dispatcher υλοποιείται μέσω Handler (Looper.getMainLooper()).

// Σωστή εναλλαγή στο Main για ενημερώσεις UI
viewModelScope.launch(Dispatchers.IO) {
    val data = repository.fetchData()
    withContext(Dispatchers.Main) {
        _uiState.value = data
    }
}

Εάν το coroutine βρίσκεται ήδη στον Main-dispatcher, το επιπλέον withContext(Dispatchers.Main) δεν δημιουργεί επιβάρυνση — ο dispatcher ελέγχει το τρέχον νήμα και παραλείπει την εναλλαγή. withContext είναι ο προτιμώμενος τρόπος εναλλαγής μεταξύ dispatchers.

Dispatchers.IO: δίκτυο και λειτουργίες δίσκου

Dispatchers.IO — dispatcher βελτιστοποιημένος για λειτουργίες εισόδου-εξόδου: αιτήματα HTTP (Ktor, OkHttp), ανάγνωση και εγγραφή αρχείων, εργασία με Room ή SQLDelight. Χρησιμοποιεί προεπιλεγμένα μια δεξαμενή 64 νημάτων, κλιμακούμενη υπό φορτίο. Κάθε νέο αίτημα IO μπορεί να δημιουργήσει ένα επιπλέον νήμα μέχρι να επιτευχθεί το όριο.

Περιορισμός παραλληλίας

Για τον έλεγχο του αριθμού ταυτόχρονων λειτουργιών IO, χρησιμοποιήστε limitedParallelism(). Αυτή η συνάρτηση δημιουργεί έναν νέο dispatcher με περιορισμό στον αριθμό των παράλληλων νημάτων, αποτρέποντας την εξάντληση της δεξαμενής σε μαζικές λειτουργίες.

val limitedIo = Dispatchers.IO.limitedParallelism(4)

// Φόρτωση 100 αρχείων με όριο 4 ταυτόχρονων λειτουργιών
coroutineScope {
    val files = (1..100).map { index ->
        async(limitedIo) {
            downloadFile("file_$index")
        }
    }
    files.awaitAll()
}

Χρησιμοποιήστε τον IO-dispatcher για όλες τις λειτουργίες όπου το coroutine περνά χρόνο αναμονής (I/O-bound). Οι εργασίες έντασης CPU στον IO-dispatcher είναι αναποτελεσματικές — καταλαμβάνουν νήματα που προορίζονται για είσοδο-έξοδο, μειώνοντας την απόδοση του συστήματος.

Dispatchers.Default: εργασίες έντασης CPU

Dispatchers.Default — dispatcher για υπολογιστικές λειτουργίες που φορτώνουν τον επεξεργαστή: ταξινόμηση, φιλτράρισμα, ανάλυση JSON (Moshi, Kotlinx Serialization), επεξεργασία εικόνας, υπολογισμοί. Το μέγεθος της δεξαμενής είναι ίσο με τον αριθμό των πυρήνων του επεξεργαστή (αλλά όχι λιγότερο από 2). Αυτό εξασφαλίζει μέγιστη φόρτωση CPU χωρίς εναλλαγή περιβάλλοντος.

suspend fun processData(input: List<RawRecord>): List<ProcessedRecord> {
    return withContext(Dispatchers.Default) {
        input
            .parallelStream()
            .map { transform(it) }
            .toList()
    }
}

Μην χρησιμοποιείτε το Dispatchers.Default για λειτουργίες IO — αυτό θα αποκλείσει τα νήματα της δεξαμενής CPU που θα μπορούσαν να επεξεργαστούν υπολογιστικές εργασίες. Ο διαχωρισμός σε IO και Default επιτρέπει τη βέλτιστη χρήση των πόρων του συστήματος: τα νήματα IO περιμένουν είσοδο-έξοδο, τα νήματα CPU είναι συνεχώς απασχολημένα με υπολογισμούς.

Dispatchers.Unconfined: τρέχον νήμα

Dispatchers.Unconfined — ένας ειδικός dispatcher που δεν δεσμεύει το coroutine σε καμία δεξαμενή. Το coroutine ξεκινά την εκτέλεση στο ίδιο νήμα όπου κλήθηκε το launch/async και μετά από αναστολή συνεχίζεται στο νήμα που κάλεσε το resume. Αυτή η συμπεριφορά είναι κατάλληλη για ενδιάμεσες λειτουργίες που δεν απαιτούν σταθερό περιβάλλον.

fun main() = runBlocking {
    launch(Dispatchers.Unconfined) {
        println("Πριν από καθυστέρηση: ${Thread.currentThread().getName()}")
        delay(500L)
        println("Μετά από καθυστέρηση: ${Thread.currentThread().getName()}")
    }
}

Σε production κώδικα, το Dispatchers.Unconfined χρησιμοποιείται σπάνια. Κύριες περιπτώσεις: ελαφροί μετασχηματισμοί πριν από τη μεταφορά δεδομένων σε άλλο dispatcher και δοκιμές. Για φορτίο παραγωγής, χρησιμοποιήστε ρητούς dispatchers — το Unconfined είναι απρόβλεπτο, καθώς το νήμα εκτέλεσης εξαρτάται από την υλοποίηση του resume.

Πώς να επιλέξετε dispatcher

Η επιλογή dispatcher καθορίζεται από τον τύπο εργασίας: λειτουργίες UI → Main, I/O-bound → IO, CPU-bound → Default, ενδιάμεσες → κληρονόμηση από scope. Για Android, συνιστάται να ξεκινάτε το coroutine στον dispatcher όπου εκτελείται η κύρια εργασία και πριν από την ενημέρωση UI να μεταβαίνετε στο Main μέσω withContext.

• Μην εκτελείτε λειτουργίες IO στον Main-dispatcher — αυτό μπλοκάρει το UI
• Μην εκτελείτε εργασίες έντασης CPU στον IO-dispatcher — αυτό χρησιμοποιεί αναποτελεσματικά τα νήματα της δεξαμενής IO
• Χρησιμοποιήστε limitedParallelism για έλεγχο παραλληλίας σε μαζικές λειτουργίες IO
• Εναλλάξτε dispatcher με withContext, όχι δημιουργώντας νέο scope
• Κληρονομήστε dispatcher από scope, εάν το coroutine δεν απαιτεί συγκεκριμένη δεξαμενή

Για σύνθετα σενάρια, συνδυάστε dispatchers με τον τελεστή +: Dispatchers.IO + SupervisorJob() + CoroutineExceptionHandler. Αυτό δημιουργεί ένα CoroutineContext με καθορισμένο dispatcher, χειρισμό σφαλμάτων και απομονωμένη ιεραρχία Job.