Πώς υλοποιείται η πολυνηματικότητα στο Kotlin;

Ο πολυνηματισμός στο Kotlin μπορεί να υλοποιηθεί με διάφορους τρόπους:

1. Τυπικά Java νήματα (Threads):

   // Υλοποίηση του interface Runnable
   class MyRunnable : Runnable {
       override fun run() {
           // Κώδικας που θα εκτελείται σε ξεχωριστό νήμα
           println("Γειά από το νήμα: ${Thread.currentThread().name}")
       }
   }
   
   fun main() {
       // Δημιουργία instance του Runnable
       val runnable = MyRunnable()
       // Δημιουργία αντικειμένου Thread με το Runnable
       val thread = Thread(runnable)
       // Εκκίνηση του νήματος
       thread.start()
   }
   

   Ή με χρήση lambda έκφρασης:

   fun main() {
       val thread = Thread {
           // Κώδικας που θα εκτελείται σε ξεχωριστό νήμα
           println("Γειά από το νήμα: ${Thread.currentThread().name}")
       }
       thread.start()
   }
   

2. Kotlin Coroutines (Κορυτίνες): Αυτή είναι η προτεινόμενη και πιο σύγχρονη προσέγγιση στο Kotlin, που παρέχει ελαφριές πολυνηματικές λειτουργίες.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       // Δημιουργία νέας κορυτίνης σε παγκόσμιο scope
       launch {
           delay(1000L) // Μη μπλοκαριστική καθυστέρηση 1 δευτερολέπτου
           println("Γειά από την κορυτίνη")
       }
       // Ο κύριος νήμα συνεχίζει
       println("Γειά από το κύριο νήμα")
       // runBlocking περιμένει την ολοκλήρωση όλων των εσωτερικών κορυτίνων
   }
   

   Παραδείγματα χρήσης διαφορετικών κατασκευαστών κορυτίνων:

   • launch: Ξεκινά μια νέα κορυτίνη χωρίς επιστρεφόμενο αποτέλεσμα.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       launch {
           println("Αυτή η κορυτίνη απλώς εκτελεί μια ενέργεια")
       }
   }
   

   • async: Ξεκινά μια νέα κορυτίνη που επιστρέφει αποτέλεσμα μέσω Deferred.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       val deferredResult = async {
           delay(1000L)
           "Αποτέλεσμα από την κορυτίνη"
       }
       val result = deferredResult.await() // Περιμένει το αποτέλεσμα
       println(result)
   }
   

3. RxKotlin/RxJava: Ο αντιδραστικός προγραμματισμός επίσης επιτρέπει εργασία με ασύγχρονες λειτουργίες και πολυνηματικότητα, χρησιμοποιώντας schedulers.

   import io.reactivex.rxjava3.core.Observable
   import io.reactivex.rxjava3.schedulers.Schedulers
   
   fun main() {
       Observable.just("Ασύγχρονο στοιχείο")
           .subscribeOn(Schedulers.io()) // Εκτέλεση εγγραφής σε νήμα I/O
           .observeOn(Schedulers.computation()) // Παρακολούθηση αποτελεσμάτων σε υπολογιστικό νήμα
           .subscribe { item ->
               println("Λήφθηκε: $item σε νήμα ${Thread.currentThread().name}")
           }
   
       Thread.sleep(2000) // Αναμονή για την ολοκλήρωση των ασύγχρονων λειτουργιών
   }
   

Η επιλογή της μεθόδου εξαρτάται από την συγκεκριμένη εργασία. Για τις περισσότερες σύγχρονες εφαρμογές Kotlin, προτιμώνται οι κορυτίνες λόγω της ελαφριάς φύσης τους, της απλότητας στη χρήση και της ενσωματωμένης υποστήριξης στη γλώσσα. Τα Java νήματα μπορεί να είναι κατάλληλα για χαμηλού επιπέδου έλεγχο, και οι αντιδραστικές βιβλιοθήκες για εργασία με ροές δεδομένων.