Πολυνηματικότητα και Ταυτοχρονισμός στην Κινητή Ανάπτυξη: Τι Είναι, Αρχές και Πώς Λειτουργεί

Τι είναι η πολυνηματικότητα;

Πολυνηματικότητα είναι η ικανότητα μιας εφαρμογής να εκτελεί πολλά τμήματα κώδικα ταυτόχρονα. Κάθε τμήμα εκτελείται σε ξεχωριστό νήμα (Thread) — μια ελαφριά διεργασία με δική της στοίβα κλήσεων. Στην κινητή ανάπτυξη, τα νήματα χωρίζονται σε δύο κατηγορίες: Main Thread (νήμα UI) και Background Threads (νήματα παρασκηνίου).

Το λειτουργικό σύστημα διαχειρίζεται την κατανομή των νημάτων στους πυρήνες του επεξεργαστή. Οι σύγχρονες συσκευές έχουν 6–8 πυρήνες, επομένως η παράλληλη εκτέλεση μπορεί να επιταχύνει την εργασία. Ωστόσο, η δημιουργία νημάτων είναι δαπανηρή λειτουργία, επομένως η άμεση εργασία με Thread δεν συνιστάται. Αντ' αυτού, χρησιμοποιούνται αφαιρέσεις υψηλότερου επιπέδου: DispatchQueue, OperationQueue, CoroutineDispatcher.

Ο ταυτοχρονισμός (Concurrency) είναι μια ευρύτερη έννοια από την πολυνηματικότητα. Ταυτοχρονισμός σημαίνει ότι οι εργασίες μπορούν να εκτελούνται "ταυτόχρονα" ακόμα και σε έναν πυρήνα μέσω εναλλαγής περιβάλλοντος. Ο ασύγχρονος προγραμματισμός (Async/Await) είναι ένα μοντέλο προγραμματισμού όπου μια εργασία δεν μπλοκάρει ένα νήμα, αλλά επιστρέφει τον έλεγχο ενώ αναμένει αποτέλεσμα. Οι σύγχρονες γλώσσες (Kotlin, Swift, Dart) έχουν ενσωματωμένη υποστήριξη για Async/Await.

Στην IT Sectr, δίνουμε ιδιαίτερη προσοχή στη σωστή αρχιτεκτονική πολυνηματικότητας στην αρχή ενός έργου. Τα λάθη που γίνονται σε πρώιμο στάδιο οδηγούν σε δύσκολα ανιχνεύσιμα σφάλματα: συνθήκες ανταγωνισμού, αδιέξοδα και αστάθεια της εφαρμογής υπό φορτίο. Κάθε έργο μας υποβάλλεται σε ανασκόπηση αρχιτεκτονικής ταυτοχρονισμού στο στάδιο του σχεδιασμού.

Κύρια νήματα (Main/Background)

Main Thread (κύριο νήμα) — το μοναδικό νήμα σε μια κινητή εφαρμογή που έχει πρόσβαση στο UI. Στο Android ονομάζεται UI Thread, στο iOS — Main Thread. Όλες οι λειτουργίες διεπαφής — αλλαγή κειμένου, κινούμενα σχέδια, επεξεργασία αφών — εκτελούνται μόνο στο Main Thread. Εάν μια βαριά λειτουργία (φόρτωση αρχείου, ανάλυση JSON) εκτελείται στο κύριο νήμα, η διεπαφή σταματά να ανταποκρίνεται. Στο Android αυτό οδηγεί σε ANR (Application Not Responding), στο iOS — σε "πάγωμα" της οθόνης.

Background Threads (νήματα παρασκηνίου) προορίζονται για οτιδήποτε δεν σχετίζεται με το UI: αιτήματα δικτύου, λειτουργίες βάσης δεδομένων, επεξεργασία εικόνας, κρυπτογραφία. Μετά την ολοκλήρωση, το αποτέλεσμα μεταφέρεται στο Main Thread για εμφάνιση. Κάθε πλατφόρμα παρέχει τα δικά της εργαλεία για εναλλαγή μεταξύ νημάτων: DispatchQueue.main.async στο iOS, runOnUiThread ή withContext(Dispatchers.Main) στο Android.

RunLoop — ο βρόχος επεξεργασίας συμβάντων στο κύριο νήμα του iOS. Το RunLoop αναμένει συμβάντα (αφές, χρονοδιακόπτες, ειδοποιήσεις) και τα διανέμει στους κατάλληλους χειριστές. Στο Android το αντίστοιχο είναι το Looper, που συνδέεται με κάθε Main Thread. Το Main Looper εξάγει άπειρα μηνύματα από την ουρά και τα μεταβιβάζει στο Handler για επεξεργασία. Η κατανόηση του RunLoop και του Looper βοηθά στην αποφυγή διαρροών μνήμης και "τραυλισμού" της διεπαφής.

GCD και OperationQueue (iOS)

Grand Central Dispatch (GCD) — βιβλιοθήκη της Apple για διαχείριση πολυνηματικότητας σε επίπεδο γλώσσας C. Το GCD λειτουργεί με DispatchQueue — ουρές εργασιών. Ο προγραμματιστής δεν δημιουργεί νήματα χειροκίνητα; το GCD διαχειρίζεται μια δεξαμενή νημάτων (Thread Pool), κατανέμοντας εργασίες στους διαθέσιμους πυρήνες του επεξεργαστή. Οι DispatchQueue είναι δύο τύπων: Serial Queue (σειριακή ουρά — οι εργασίες εκτελούνται η μία μετά την άλλη) και Concurrent Queue (ταυτόχρονη ουρά — οι εργασίες μπορούν να εκτελούνται ταυτόχρονα).

Main DispatchQueue — μια σειριακή ουρά συνδεδεμένη με το κύριο νήμα. Global Queues — ταυτόχρονες ουρές με διαφορετικές προτεραιότητες (QoS — Quality of Service): userInteractive, userInitiated, utility, background. Η επιλογή του σωστού QoS είναι κρίσιμη για την απόδοση: .userInteractive — για εργασίες που επηρεάζουν το UI (κινουμένα σχέδια, απόδοση); .background — για εργασίες μη κρίσιμες ως προς τον χρόνο (συγχρονισμός, καθαρισμός cache).

OperationQueue — μια αφαίρεση πάνω από το GCD με πρόσθετες δυνατότητες: ακύρωση εργασιών, καθορισμός εξαρτήσεων μεταξύ λειτουργιών, έλεγχος μέγιστου αριθμού ταυτόχρονων λειτουργιών. Οι λειτουργίες είναι αντικείμενα της κλάσης Operation (ή BlockOperation). Παράδειγμα: εάν πρέπει να φορτώσετε μια εικόνα, στη συνέχεια να εφαρμόσετε ένα φίλτρο και μόνο τότε να την εμφανίσετε — η OperationQueue με εξαρτήσεις το χειρίζεται τέλεια. Στο GCD θα πρέπει να συγχρονίσετε χειροκίνητα αυτά τα βήματα χρησιμοποιώντας DispatchGroup ή σημαφόρο.

Async/Await στο Swift 5.5+ — μια σύγχρονη εναλλακτική στο GCD. Οι λέξεις-κλειδιά async και await καθιστούν τον ασύγχρονο κώδικα γραμμικό και ευανάγνωστο. Οι συναρτήσεις επισημαίνονται ως async και οι κλήσεις αναμένονται μέσω await. Το σύστημα διαχειρίζεται την εναλλαγή περιβάλλοντος: από προεπιλογή, μια async συνάρτηση εκτελείται σε ένα νήμα παρασκηνίου, ενώ η ενημέρωση UI εκτελείται στο MainActor. @MainActor — ένα χαρακτηριστικό που εγγυάται την εκτέλεση κώδικα στο κύριο νήμα.

Coroutines και Flow (Kotlin)

Coroutines (κορουτίνες) — ελαφριά νήματα για Kotlin που αναπτύχθηκαν από την JetBrains. Σε αντίθεση με τα συνηθισμένα νήματα, οι κορουτίνες δεν είναι δεσμευμένες σε ένα συγκεκριμένο Thread. Χιλιάδες κορουτίνες μπορούν να εκτελούνται σε πολλά νήματα χωρίς σημαντική επιβάρυνση. CoroutineScope διαχειρίζεται τον κύκλο ζωής των κορουτίνων: το viewModelScope συνδέεται με το ViewModel, το lifecycleScope — με το Activity/Fragment. Όταν το πεδίο καταστρέφεται, όλες οι θυγατρικές κορουτίνες ακυρώνονται αυτόματα.

Τα Dispatchers καθορίζουν σε ποια δεξαμενή νημάτων εκτελείται η κορουτίνα: Dispatchers.Main — νήμα UI; Dispatchers.IO — για αιτήματα δικτύου και λειτουργίες δίσκου; Dispatchers.Default — για υπολογισμούς έντασης CPU. Για εναλλαγή dispatcher χρησιμοποιείται το withContext. Οι κορουτίνες υποστηρίζουν δομημένο ταυτοχρονισμό: κάθε κορουτίνα έχει έναν γονέα και όταν ο γονέας ακυρώνεται, όλες οι θυγατρικές κορουτίνες ακυρώνονται. Αυτό αποτρέπει διαρροές μνήμης και εκκρεμείς εργασίες.

Flow — μια ψυχρή ασύγχρονη ροή δεδομένων από τη βιβλιοθήκη κορουτίνων. Το Flow εκπέμπει τιμές διαδοχικά: (1) ο παραγωγός δημιουργεί δεδομένα, (2) οι τελεστές μετασχηματίζουν τη ροή, (3) ο συλλέκτης καταναλώνει το αποτέλεσμα. Σε αντίθεση με το LiveData, το Flow υποστηρίζει σύνθετες αλυσίδες τελεστών (map, filter, flatMapConcat, catch) και είναι πλήρως ασφαλές για νήματα. StateFlow και SharedFlow — θερμές παραλλαγές του Flow, ιδανικές για κατάσταση UI και εφάπαξ συμβάντα (Snackbar, πλοήγηση).

Channel — μια άλλη αφαίρεση κορουτίνων για μεταβίβαση δεδομένων μεταξύ κορουτίνων. Το Channel λειτουργεί σαν ουρά: ένας αποστολέας (send) και ένας ή περισσότεροι παραλήπτες (receive). Τα κανάλια με buffer (Channel(UNLIMITED), Channel(BUFFERED)) επιτρέπουν τη διαμόρφωση συμπεριφοράς σε υπερχείλιση. Το Channel χρησιμοποιείται συχνά με το Flow για γεφύρωση API βασισμένων σε callback με κορουτίνες: callbackFlow { … }.

Στην IT Sectr χρησιμοποιούμε ενεργά κορουτίνες και Flow σε όλα τα έργα Android. Αυτό επιτρέπει τη σύνταξη ασύγχρονου κώδικα που μοιάζει σύγχρονος, είναι εύκολος στη δοκιμή (runTest, TestDispatcher) και δεν απαιτεί χειροκίνητη διαχείριση νημάτων. Παράδειγμα μιας απλής κορουτίνας με φόρτωση δεδομένων:

class UserRepository(
    private val api: UserApi,
    private val dao: UserDao
) {
    suspend fun getUsers(): List<User> = withContext(Dispatchers.IO) {
        return@withContext try {
            val users = api.fetchUsers()
            dao.insertAll(users)
            users
        } catch (e: Exception) {
            dao.getAll()
        }
    }
}

Rx και Combine

Αντιδραστικός προγραμματισμός — ένα παράδειγμα όπου τα δεδομένα διαδίδονται ως ασύγχρονες ροές (Observable, Publisher). RxJava/RxKotlin — η πιο δημοφιλής υλοποίηση για Android, μεταφερμένη από το .NET Rx. RxSwift — παρόμοια βιβλιοθήκη για iOS. Κύρια συστατικά: Observable (πηγή συμβάντων), Observer (συνδρομητής), Scheduler (διαχείριση νημάτων), Operators (μετασχηματισμός ροής).

Combine — ένα πλαίσιο της Apple για αντιδραστικό προγραμματισμό που παρουσιάστηκε στο iOS 13. Το Combine χρησιμοποιεί τα πρωτόκολλα Publisher (εκδότης) και Subscriber (συνδρομητής). Σε αντίθεση με το RxSwift, το Combine είναι ενσωματωμένο στο SDK και στενά συνδεδεμένο με το SwiftUI. Τελεστές στο Combine: map, filter, combineLatest, zip, debounce, throttle — καλύπτουν τα περισσότερα σενάρια: από τη σύνδεση δεδομένων στο UI μέχρι το debounce ερωτήματος αναζήτησης.

Future και Promise — μοτίβα για εργασία με ένα μόνο ασύγχρονο αποτέλεσμα. Το Future αντιπροσωπεύει μια τιμή που θα είναι διαθέσιμη αργότερα. Το Promise είναι μια υπόσχεση παροχής τιμής. Στο Rx αυτό είναι Single (μία επιτυχημένη απόκριση ή σφάλμα), στο Combine — Future Publisher. Στην πράξη, τα Future/Promise είναι βολικά για μεμονωμένα αιτήματα API, ενώ τα Observable/Publisher — για συνεχείς ροές (γεωτοποθεσία, εισαγωγή κειμένου).

Callback και Delegate — κλασικά μοτίβα για ασύγχρονες λειτουργίες. Callback — μια συνάρτηση που μεταβιβάζεται ως όρισμα και καλείται κατά την ολοκλήρωση της λειτουργίας. Delegate — ένα αντικείμενο που υλοποιεί ένα πρωτόκολλο με μεθόδους χειρισμού συμβάντων. Μειονέκτημα: "callback hell" (φωλιασμένα callback) και πολυπλοκότητα διαχείρισης σφαλμάτων. NotificationCenter (iOS) και EventBus (Android) — μηχανισμοί εκπομπής συμβάντων, χρήσιμοι για χαλαρά συνδεδεμένη επικοινωνία αλλά οδηγούν σε σιωπηρές εξαρτήσεις.

Προβλήματα πολυνηματικότητας (Race Condition, Deadlock)

Η πολυνηματικότητα ανοίγει την πόρτα σε υψηλή απόδοση, αλλά ταυτόχρονα δημιουργεί κίνδυνο δύσκολα ανιχνεύσιμων σφαλμάτων. Τα πιο κοινά: Race Condition (συνθήκη ανταγωνισμού), Deadlock (αδιέξοδο), Livelock (ενεργό αδιέξοδο) και Starvation (λιμοκτονία νήματος). Η κατανόηση αυτών των προβλημάτων είναι υποχρεωτική δεξιότητα για κάθε κινητό προγραμματιστή.

Race Condition

Το Race Condition εμφανίζεται όταν δύο ή περισσότερα νήματα διαβάζουν και γράφουν τα ίδια δεδομένα ταυτόχρονα χωρίς συγχρονισμό. Το αποτέλεσμα εξαρτάται από το ποιο νήμα εκτελείται πρώτο. Κλασικό παράδειγμα: δύο νήματα αυξάνουν έναν μετρητή. Η λειτουργία "διάβασε → αύξησε → γράψε" δεν είναι ατομική, επομένως όταν εκτελείται ταυτόχρονα, μία αύξηση "χάνεται". Η λύση — χρήση ατομικών λειτουργιών (AtomicInteger, AtomicReference) ή κλειδωμάτων (Mutex, Semaphore, synchronized).

Deadlock

Deadlock — μια κατάσταση όπου κάθε νήμα κατέχει έναν πόρο και αναμένει έναν πόρο που κατέχεται από άλλο νήμα. Κανένα νήμα δεν μπορεί να συνεχίσει. Συνθήκες εμφάνισης: αμοιβαίος αποκλεισμός, κατοχή και αναμονή, χωρίς προεκβολή, κυκλική αναμονή. Πρόληψη: καθορισμός ενιαίας σειράς απόκτησης κλειδωμάτων, χρήση tryLock με χρονικό όριο, εφαρμογή αλγορίθμων Lock-Free (ConcurrentHashMap, CopyOnWriteArrayList).

Livelock και Starvation

Livelock — τα νήματα δεν είναι μπλοκαρισμένα αλλά "περνάνε" συνεχώς πόρους το ένα στο άλλο χωρίς να εκτελούν χρήσιμη εργασία. Παράδειγμα: δύο άτομα συναντιούνται σε έναν διάδρομο και και τα δύο παραμερίζουν, κινούμενα προς την ίδια κατεύθυνση. Starvation — ένα νήμα δεν αποκτά πρόσβαση σε έναν πόρο επειδή άλλα νήματα τον αναχαιτίζουν συνεχώς. Λύση: δίκαια κλειδώματα (fair locks), προτεραιότητες νημάτων με προσοχή.

Εργαλεία συγχρονισμού

Για την πρόληψη προβλημάτων πολυνηματικότητας χρησιμοποιούνται πρωτόγονοι συγχρονισμού: Mutex (αμοιβαίος αποκλεισμός), Semaphore (περιορισμός αριθμού ταυτόχρονων προσβάσεων), Lock (διεπαφή με tryLock), Synchronized (κλείδωμα επιπέδου JVM), @MainActor (Swift — εγγύηση εκτέλεσης στο κύριο νήμα). Στο Android είναι επίσης διαθέσιμο το ThreadPool μέσω Executors.newFixedThreadPool, newCachedThreadPool. Ωστόσο, η χειροκίνητη διαχείριση δεξαμενών είναι προνόμιο παλαιών έργων; στα νέα έργα είναι καλύτερο να χρησιμοποιούνται κορουτίνες.