Thread στην ανάπτυξη εφαρμογών για κινητά — τι είναι, τύποι και διαχείριση νημάτων

Τι είναι το Thread

Thread (νήμα εκτέλεσης) — μια ανεξάρτητη ακολουθία εντολών που το λειτουργικό σύστημα μπορεί να προγραμματίσει σε έναν πυρήνα CPU. Κάθε διεργασία (εφαρμογή) περιέχει τουλάχιστον ένα νήμα — Main Thread. Πρόσθετα νήματα δημιουργούνται για την παράλληλη εκτέλεση εργασιών. Κάθε νήμα έχει τη δική του στοίβα προγράμματος (με τοπικές μεταβλητές), μετρητή εντολών (PC) και καταχωρητές. Η μνήμη heap είναι κοινή για όλα τα νήματα της διεργασίας.

Στα λειτουργικά συστήματα κινητών, τα νήματα προγραμματίζονται με προληπτική πολυεπεξεργασία (preemptive multitasking): το λειτουργικό σύστημα μπορεί να διακόψει την εκτέλεση ενός νήματος ανά πάσα στιγμή και να μεταβιβάσει τον έλεγχο σε άλλο (context switch). Η εναλλαγή περιβάλλοντος είναι δαπανηρή λειτουργία (1–10 μικροδευτερόλεπτα), επειδή απαιτεί αποθήκευση/επαναφορά των καταχωρητών CPU, ενημέρωση του TLB και εκκαθάριση των κρυφών μνημών. Γι' αυτό ακριβώς ο υπερβολικός αριθμός νημάτων (εκατοντάδες και χιλιάδες) υποβαθμίζει την απόδοση — το λειτουργικό σύστημα ξοδεύει περισσότερο χρόνο στην εναλλαγή παρά στην εκτέλεση.

Νήμα και διεργασία είναι διαφορετικές έννοιες. Η διεργασία είναι μια παρουσία της εφαρμογής με αποκλειστική εικονική μνήμη. Το νήμα μέσα στη διεργασία μοιράζεται αυτή τη μνήμη με άλλα νήματα. Στο Android, κάθε στοιχείο της εφαρμογής (Activity, Service, BroadcastReceiver) λειτουργεί σε μία διεργασία, αλλά μπορεί να εκτελείται σε διαφορετικά νήματα. Η εφαρμογή iOS είναι επίσης μία διεργασία με δυνατότητα δημιουργίας πρόσθετων νημάτων μέσω GCD ή Thread.

Κύκλος ζωής νήματος: καταστάσεις και μεταβάσεις

Κάθε νήμα σε Java/Kotlin (Android) και NSThread (iOS) περνά από πέντε καταστάσεις: New (δημιουργήθηκε), Runnable (έτοιμο για εκτέλεση), Running (εκτελείται σε CPU), Blocked/Waiting (περιμένει πόρο ή ειδοποίηση), Terminated (ολοκληρώθηκε). Οι μεταβάσεις μεταξύ των καταστάσεων ελέγχονται από τον χρονοπρογραμματιστή του λειτουργικού συστήματος και τα αρχέγονα συγχρονισμού. Ο προγραμματιστής μπορεί να επηρεάσει την προτεραιότητα του νήματος (Thread.setPriority()) και την κατάστασή του (sleep, join, interrupt).

Στο Android, το νήμα περνά στην κατάσταση Blocked όταν προσπαθεί να καταλάβει έναν κατειλημμένο monitor (synchronized), όταν καλεί Object.wait() ή Thread.sleep(). Στο iOS — όταν καλεί NSCondition.wait(), pthread_cond_wait() ή dispatch_semaphore_wait(). Στην κατάσταση Blocked το νήμα δεν καταναλώνει CPU, αλλά καταλαμβάνει μνήμη (στοίβα). Το νήμα μπορεί να διακοπεί (interrupted) από άλλο νήμα, λαμβάνοντας InterruptedException (Java) ή ελέγχοντας το isCancelled (Kotlin Coroutines).

Context Switch και το κόστος του

Context switch (εναλλαγή περιβάλλοντος) — η λειτουργία κατά την οποία το λειτουργικό σύστημα αποθηκεύει την κατάσταση του τρέχοντος νήματος (καταχωρητές, PC, TLB) και φορτώνει την αποθηκευμένη κατάσταση ενός άλλου. Στα συστήματα κινητών (Linux + ART, XNU για iOS), το context switch διαρκεί 1–10 μικροδευτερόλεπτα. Αν ένα νήμα εκτελεί μια εργασία σε 100 μικροδευτερόλεπτα και το context switch διαρκεί 5, τότε χάνεται το 5% του χρόνου. Για την ελαχιστοποίηση του context switch, το iOS χρησιμοποιεί GCD με work stealing, και το Android — pools με fixedThreadCount.

Thread σε Android: από Thread έως Coroutines

Το Android εξελίχθηκε από το χαμηλού επιπέδου java.lang.Thread στα σύγχρονα coroutines. Κάθε επίπεδο αφαίρεσης δίνει περισσότερες δυνατότητες με μικρότερο πρόσθετο κόστος. Το Thread είναι η βασική κλάση, αλλά η άμεση δημιουργία του δεν συνιστάται: το νέο νήμα δεν διαχειρίζεται από pool, είναι δύσκολο να παρακολουθηθεί και να ακυρωθεί. Το AsyncTask (deprecated από το API 30) ήταν ένα βήμα μπροστά, αλλά υπέφερε από διαρροές μνήμης και μη βολική διαχείριση διαμορφώσεων.

HandlerThread — ειδική υποκλάση του Thread με Looper, που μπορεί να επεξεργάζεται ουρά μηνυμάτων. Χρησιμοποιείται για τη σειριακή εκτέλεση εργασιών σε νήμα παρασκηνίου, για παράδειγμα, εγγραφή δεδομένων σε Room ή αρχεία. Το HandlerThread δημιουργείται με την κλήση start(), μετά την οποία μέσω του Handler(handlerThread.looper) μπορούν να αποσταλούν μηνύματα και Runnable. Η κλήση handlerThread.quit() σταματά το Looper και τερματίζει το νήμα.

// Android: Thread, HandlerThread και Executors
import android.os.Handler
import android.os.HandlerThread
import java.util.concurrent.Executors

class ThreadExample {

    // 1. Άμεση δημιουργία Thread (δεν συνιστάται)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Άμεσο νήμα εκτελέστηκε")
        })
        thread.start()
    }

    // 2. HandlerThread για σειριακές εργασίες παρασκηνίου
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Σειριακή εκτέλεση σε νήμα παρασκηνίου
            Thread.sleep(500)
            print("HandlerThread: η εργασία ολοκληρώθηκε")
        }

        // Διακοπή νήματος (εκτελείται όταν ολοκληρωθούν οι εργασίες)
        handlerThread.quitSafely()
    }

    // 3. Executors — pool νημάτων
    fun executorExample() {
        val executor = Executors.newFixedThreadPool(4)
        for (i in 1..10) {
            executor.execute {
                print("Task $i on thread ${Thread.currentThread().getName()}")
            }
        }
        executor.shutdown()
    }

    // 4. Kotlin Coroutines — σύγχρονο πρότυπο
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

Το παράδειγμα ThreadExample δείχνει και τα τέσσερα επίπεδα αφαίρεσης νημάτων στο Android. Η άμεση δημιουργία Thread είναι η χαμηλότερου επιπέδου και λιγότερο αποδοτική προσέγγιση. Το HandlerThread είναι χρήσιμο για σειριακές εργασίες στο παρασκήνιο. Το Executors.newFixedThreadPool(4) δημιουργεί pool 4 νημάτων για παράλληλη εκτέλεση έως 10 εργασιών. Το Kotlin Coroutines με Dispatchers.Default — σύγχρονος, αποδοτικός και ασφαλής τρόπος.

HandlerThread: σειριακές εργασίες παρασκηνίου

HandlerThread — εξειδικευμένη υποκλάση του Thread με ενσωματωμένο Looper και ουρά μηνυμάτων. Δημιουργείται με την κλήση start(), μετά την οποία μέσω του Handler(handlerThread.looper) μπορούν να αποσταλούν Runnable και μηνύματα. Το HandlerThread εκτελεί τις εργασίες αυστηρά σειριακά — η επόμενη εργασία δεν ξεκινά μέχρι να ολοκληρωθεί η προηγούμενη. Αυτό είναι βολικό για την εγγραφή δεδομένων σε Room ή αρχεία, όπου η σειρά των λειτουργιών είναι κρίσιμη. Η κλήση quitSafely() σταματά το Looper μετά την ολοκλήρωση της τρέχουσας εργασίας.

import Foundation

class ThreadManager {

    // 1. Thread (χαμηλού επιπέδου)
    func createThread() {
        let thread = Thread {
            // Ο κώδικας εκτελείται σε νέο νήμα
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

    // 2. GCD — DispatchQueue
    func gcdExample() {
        // Παράλληλη ουρά
        let queue = DispatchQueue(label: "com.app.concurrent",
                                 qos: .utility,
                                 attributes: .concurrent)

        queue.async {
            print("Ασύγχρονη εργασία GCD")
        }

        // Barrier για συγχρονισμό εγγραφής
        queue.async(flags: .barrier) {
            // Αποκλειστική πρόσβαση κατά την εγγραφή
            print("Barrier write: αποκλειστική πρόσβαση")
        }
    }

    // 3. OperationQueue με εξαρτήσεις
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Λήψη...")
        }
        let process = BlockOperation {
            print("Επεξεργασία...")
        }
        let save = BlockOperation {
            print("Αποθήκευση...")
        }

        // Εξαρτήσεις: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

        queue.addOperations([download, process, save], waitUntilFinished: false)
    }
}

// Thread-safe συλλογή μέσω GCD barrier
class ThreadSafeArray<T> {
    private var array: [T] = []
    private let queue = DispatchQueue(label: "com.app.concurrent",
                                       attributes: .concurrent)

    var count: Int {
        return queue.sync { array.count } // concurrent read
    }

    func append(_ element: T) {
        queue.async(flags: .barrier) { // exclusive write
            self.array.append(element)
        }
    }
}

// Συγχρονισμός σε Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — για απλούς μετρητές
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — για κρίσιμα τμήματα
    @Synchronized
    fun synchronizedOperation() {
        // Μόνο ένα νήμα τη φορά
        doWork()
    }

    // 3. Mutex από coroutines — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // protected code — thread-safe
            doWork()
        }
    }

    private fun doWork() { /* critical section */ }
}

// Παράδειγμα deadlock: A μπλοκάρει το B, B μπλοκάρει το A
class DeadlockExample {
    private val lockA = Any()
    private val lockB = Any()

    fun methodA() = synchronized(lockA) {
        Thread.sleep(100)
        synchronized(lockB) { print("OK") }
    }

    fun methodB() = synchronized(lockB) {
        Thread.sleep(100)
        synchronized(lockA) { print("OK") }
    }
}