Thread Pool στην κινητή ανάπτυξη — βασικά, δεξαμενή νημάτων και αρχή λειτουργίας

Τι είναι το Thread Pool;

Thread Pool (δεξαμενή νημάτων) — είναι ένα αρχιτεκτονικό μοτίβο όπου ένας σταθερός αριθμός νημάτων δημιουργείται εκ των προτέρων και επαναχρησιμοποιείται για την εκτέλεση πολλών εργασιών. Αντί να δημιουργείται ένα νέο νήμα για κάθε λειτουργία (το οποίο είναι δαπανηρό: περίπου 1 MB στοίβας ανά νήμα στο JVM), οι εργασίες τοποθετούνται σε μια ουρά και εκτελούνται από ελεύθερα νήματα από τη δεξαμενή. Στην κινητή ανάπτυξη, η δεξαμενή νημάτων είναι κρίσιμη για την απόδοση — το Android και το iOS περιορίζουν τον αριθμό νημάτων ανά εφαρμογή.

Γιατί το Thread Pool είναι σημαντικό στην κινητή ανάπτυξη

Η δημιουργία ενός νήματος είναι μια δαπανηρή λειτουργία: κατανομή στοίβας, εγγραφή στο σύστημα, εναλλαγή περιβάλλοντος. Σε κινητές συσκευές με περιορισμένους πόρους, η ανεξέλεγκτη δημιουργία νημάτων οδηγεί σε OOM (OutOfMemoryError) στο Android και σε throttling στο iOS. Thread Pool λύνει και τα δύο προβλήματα: περιορίζει τον μέγιστο αριθμό ταυτόχρονα ενεργών νημάτων και επαναχρησιμοποιεί ήδη δημιουργημένα νήματα. Η Google συνιστά ExecutorService αντί για raw Thread(), η Apple συνιστά OperationQueue αντί για Thread.

Πώς λειτουργεί το Thread Pool στην κινητή ανάπτυξη;

Η δεξαμενή νημάτων λειτουργεί με βάση την αρχή Producer-Consumer: οι εργασίες (Runnable/Callable) τοποθετούνται σε μια ουρά αποκλεισμού (BlockingQueue). Τα νήματα από τη δεξαμενή περιμένουν εργασίες στην ουρά και τις παραλαμβάνουν για εκτέλεση. Αλγόριθμος: αν τα ελεύθερα νήματα είναι λιγότερα από το corePoolSize, δημιουργείται ένα νέο νήμα. Αν έχει επιτευχθεί το corePoolSize, η εργασία τοποθετείται στην ουρά. Αν η ουρά είναι γεμάτη και τα νήματα είναι λιγότερα από το maximumPoolSize, δημιουργείται ένα επιπλέον νήμα. Υπέρβαση του maximumPoolSize έχει ως αποτέλεσμα την απόρριψη της εργασίας μέσω RejectedExecutionHandler.

Core Pool Size vs Maximum Pool Size

Core pool size — ο αριθμός νημάτων που διατηρούνται στη δεξαμενή ακόμη και σε αδράνεια. Maximum pool size — ο μέγιστος αριθμός νημάτων που μπορούν να δημιουργηθούν όταν η ουρά υπερχειλίσει. Η διαφορά μεταξύ τους είναι επιπλέον (overflow) νήματα που δημιουργούνται προσωρινά και τερματίζονται μετά από χρονικό όριο αδράνειας. Σε κινητές συσκευές, συνιστάται η ρύθμιση του corePoolSize ίσου με το maximumPoolSize για αποφυγή φορτίων αιχμής κατά τη δημιουργία νημάτων.

Work Queue και RejectedExecutionHandler

BlockingQueue αποθηκεύει εργασίες που περιμένουν εκτέλεση. Οι πιο δημοφιλείς υλοποιήσεις: LinkedBlockingQueue (απεριόριστη), ArrayBlockingQueue (περιορισμένη) και SynchronousQueue (χωρίς αποθήκευση — η εργασία μεταβιβάζεται αμέσως στο νήμα). Όταν η ουρά και η δεξαμενή υπερχειλίσουν, ενεργοποιείται ο RejectedExecutionHandler. Τυπικές πολιτικές: AbortPolicy (ρίχνει RejectedExecutionException), CallerRunsPolicy (εκτελεί στο νήμα του αποστολέα), DiscardPolicy και DiscardOldestPolicy.

// Δημιουργία Thread Pool στο Android
val threadPool = ThreadPoolExecutor(
    corePoolSize = 2,        // Ελάχιστο 2 νήματα
    maximumPoolSize = 4,     // Μέγιστο 4 νήματα
    keepAliveTime = 30L,     // Διάρκεια ζωής νήματος υπερχείλισης
    unit = TimeUnit.SECONDS,
    workQueue = LinkedBlockingQueue<Runnable>(16),
    threadFactory = Executors.defaultThreadFactory(),
    handler = ThreadPoolExecutor.CallerRunsPolicy()
)

// Αποστολή εργασιών
threadPool.execute {
    val result = api.fetchData()
    runOnUiThread { showData(result) }
}

// Τερματισμός δεξαμενής
threadPool.shutdown()
// Αναμονή ολοκλήρωσης όλων των εργασιών
threadPool.awaitTermination(10, TimeUnit.SECONDS)

Thread Pool στο Android: ExecutorService

Το Android παρέχει διάφορες υλοποιήσεις δεξαμενής νημάτων μέσω του java.util.concurrent. Executors — ένα εργοστάσιο με έτοιμες διαμορφώσεις: newFixedThreadPool(n) (σταθερή δεξαμενή), newCachedThreadPool() (απεριόριστη, νήματα δημιουργούνται όταν χρειαστεί), newSingleThreadExecutor() (ένα νήμα — σειριακή εκτέλεση). Για κινητά έργα, συνιστάται το newFixedThreadPool με λογικό όριο (2-4 νήματα), καθώς το cached pool μπορεί να δημιουργήσει πάρα πολλά νήματα.

ThreadPoolExecutor στο Android

ThreadPoolExecutor (TPE) — η πλήρης υλοποίηση του ExecutorService με παραμετροποιήσιμες παραμέτρους. Στο Android, το TPE χρησιμοποιείται εντός των AsyncTask, IntentService και JobIntentService. Οι παράμετροι corePoolSize, maximumPoolSize, keepAliveTime, BlockingQueue και RejectedExecutionHandler επιτρέπουν τη λεπτομερή ρύθμιση της συμπεριφοράς της δεξαμενής. Συστάσεις για Android: corePoolSize = αριθμός πυρήνων CPU - 1 (για εργασίες IO-bound) ή αριθμός πυρήνων (για εργασίες CPU-bound). Για τυπικές εφαρμογές — 2-4 νήματα.

// Έτοιμες διαμορφώσεις Executors
// 1. Σταθερή δεξαμενή 3 νημάτων
val fixedPool = Executors.newFixedThreadPool(3)

// 2. Προσωρινή δεξαμενή (δεν συνιστάται για κινητά)
val cachedPool = Executors.newCachedThreadPool()

// 3. Μονό νήμα (σειριοποίηση)
val singlePool = Executors.newSingleThreadExecutor()

// 4. Χρονοπρογραμματιστής (περιοδικές εργασίες)
val scheduler = Executors.newScheduledThreadPool(2)

// Χρήση με Callable και Future
val future: Future<String> = fixedPool.submit(Callable {
    "Result: ${api.call()}"
})
// Λήψη αποτελέσματος (μπλοκάρει το νήμα)
val result = future.get(5, TimeUnit.SECONDS)

// Τερματισμός δεξαμενής
fixedPool.shutdownNow()

CoroutineDispatcher ως δεξαμενή νημάτων

Τα Kotlin coroutine παρέχουν CoroutineDispatcher — μια αφαίρεση παρόμοια με τη δεξαμενή νημάτων. Το Dispatchers.IO χρησιμοποιεί μια δεξαμενή 64 νημάτων (περιορισμένη). Dispatchers.Default — δεξαμενή ίση με τον αριθμό πυρήνων CPU. Το CoroutineDispatcher δεν απαιτεί χειροκίνητο τερματισμό και διαχειρίζεται αυτόματα. Για λεπτομερή ρύθμιση, δημιουργήστε το δικό σας ExecutorCoroutineDispatcher μέσω Executors.newFixedThreadPool(2).asCoroutineDispatcher(). Τα coroutine δεν αντικαθιστούν τη δεξαμενή νημάτων, αλλά την περιτυλίγουν.

Thread Pool στο iOS: OperationQueue και GCD

Το iOS παρέχει δύο κύριους μηχανισμούς διαχείρισης της δεξαμενής νημάτων: OperationQueue (υψηλού επιπέδου API βασισμένο στο GCD) και GCD DispatchQueue (χαμηλού επιπέδου C-API). Το OperationQueue ενσωματώνει τη δεξαμενή νημάτων μέσω της ιδιότητας maxConcurrentOperationCount. Από προεπιλογή, το OperationQueue χρησιμοποιεί system-defined maximum (ανάλογα με το φορτίο του συστήματος). Το DispatchQueue.global() παρέχει μια ταυτόχρονη ουρά με τη δεξαμενή νημάτων συστήματος.

OperationQueue και maxConcurrentOperationCount

OperationQueue διαχειρίζεται τη δεξαμενή νημάτων μέσω του maxConcurrentOperationCount. Η τιμή 1 δημιουργεί μια σειριακή ουρά (παρόμοια με single thread pool). Η τιμή μεγαλύτερη από 1 — ταυτόχρονη δεξαμενή με καθορισμένο όριο. Από προεπιλογή, maxConcurrentOperationCount = NSOperationQueueDefaultMaxConcurrentOperationCount (βέλτιστο συστήματος, συνήθως 4-8 νήματα). Το Operation υποστηρίζει εξαρτήσεις, προτεραιότητες και ακύρωση. Κάθε λειτουργία εκτελείται σε οποιοδήποτε ελεύθερο νήμα από τη δεξαμενή συστήματος.

// OperationQueue με δεξαμενή 3 νημάτων
let queue = OperationQueue()
queue.maxConcurrentOperationCount = 3
queue.qualityOfService = .utility

// Δημιουργία λειτουργιών
let operation1 = BlockOperation {
    let data = fetchData(from: url1)
    DispatchQueue.main.async { updateUI(data) }
}

let operation2 = BlockOperation {
    let data = fetchData(from: url2)
    DispatchQueue.main.async { updateUI(data) }
}

// Εξάρτηση: operation2 περιμένει το operation1
operation2.addDependency(operation1)

// Προσθήκη στην ουρά
queue.addOperations([operation1, operation2], waitUntilFinished: false)

// Ακύρωση όλων των λειτουργιών
queue.cancelAllOperations()

GCD DispatchQueue ως δεξαμενή νημάτων

DispatchQueue — είναι η δεξαμενή νημάτων της Apple. Η ταυτόχρονη ουρά (qos: .utility) χρησιμοποιεί τη δεξαμενή νημάτων συστήματος, βελτιστοποιημένη για το τρέχον φορτίο της συσκευής. Διαφορετικά QoS (userInteractive, userInitiated, utility, background) αντιστοιχίζονται σε διαφορετικές δεξαμενές με διαφορετικές προτεραιότητες. DispatchGroup επιτρέπει τον συγχρονισμό πολλών εργασιών. Το DispatchWorkItem υποστηρίζει ακύρωση και qualityOfService. Για λεπτομερή έλεγχο, δημιουργήστε τις δικές σας ταυτόχρονες ουρές μέσω DispatchQueue(label: qos: attributes: .concurrent).

// GCD DispatchQueue ως δεξαμενή νημάτων
let customQueue = DispatchQueue(
    label: "com.app.background",
    qos: .utility,
    attributes: .concurrent,
    autoreleaseFrequency: .workItem
)

// Αποστολή εργασιών στη δεξαμενή
customQueue.async { self.processFile(file1) }
customQueue.async { self.processFile(file2) }

// DispatchGroup για συγχρονισμό
let group = DispatchGroup()
let pool = DispatchQueue.global(qos: .utility)

pool.async(group: group) { fetchData() }
pool.async(group: group) { processImage() }

group.notify(queue: .main) {
    self.showResult() // Και οι δύο εργασίες ολοκληρώθηκαν
}

// Περιορισμός ταυτοχρονισμού μέσω semaphore
let semaphore = DispatchSemaphore(value: 3)
for url in urls {
    pool.async {
        semaphore.wait()
        download(url)
        semaphore.signal()
    }
}

Παράμετροι διαμόρφωσης Thread Pool

Η διαμόρφωση της δεξαμενής νημάτων επηρεάζει άμεσα την απόδοση της εφαρμογής. Λανθασμένες παράμετροι οδηγούν σε υποχρησιμοποίηση της CPU (πολύ λίγα νήματα) ή υπερφόρτωση του συστήματος (πάρα πολλά). Σε κινητές εφαρμογές, οι βέλτιστες τιμές διαφέρουν από τις τιμές διακομιστή λόγω περιορισμένων πόρων και κατανάλωσης ενέργειας. Κύριες παράμετροι: corePoolSize, maxPoolSize, queue capacity και keepAliveTime.

Υπολογισμός βέλτιστου μεγέθους δεξαμενής

Τύπος για εργασίες IO-bound: corePoolSize = αριθμός πυρήνων CPU × 2 (τα νήματα περιμένουν είσοδο-έξοδο). Για εργασίες CPU-bound: corePoolSize = αριθμός πυρήνων CPU (τα νήματα είναι συνεχώς απασχολημένα με υπολογισμούς). Σε σύγχρονες κινητές συσκευές (6-8 πυρήνες), αυτό δίνει 6-8 νήματα για CPU-bound και 12-16 για IO-bound. Πρακτικές δοκιμές δείχνουν ότι για μια τυπική κινητή εφαρμογή, 3-4 νήματα είναι βέλτιστα — περισσότερα νήματα αυξάνουν την κατανάλωση ενέργειας χωρίς βελτίωση της απόδοσης.

Queue Capacity και συμπεριφορά σε υπερχείλιση

Το μέγεθος της ουράς εργασιών (work queue) καθορίζει πόσες εργασίες μπορούν να περιμένουν εκτέλεση. Απεριόριστη ουρά (LinkedBlockingQueue χωρίς όριο) μπορεί να οδηγήσει σε OOM κατά την ταχεία άφιξη εργασιών. Περιορισμένη ουρά (ArrayBlockingQueue με σταθερό μέγεθος) απορρίπτει εργασίες σε υπερχείλιση. Για κινητές εφαρμογές, συνιστάται ArrayBlockingQueue με χωρητικότητα 16-32 εργασιών. CallerRunsPolicy — ο καλύτερος RejectedExecutionHandler για κινητές συσκευές: επιβραδύνει τον αποστολέα (pressure back) αντί να χάνει την εργασία.

Συνήθη λάθη κατά την εργασία με δεξαμενή νημάτων

Οι προγραμματιστές κινητών εφαρμογών συχνά κάνουν λάθη κατά τη χρήση της δεξαμενής νημάτων, που οδηγούν σε σφάλματα, διαρροές μνήμης και ασταθή λειτουργία. Συχνότερα: μη κλήση του shutdown() για ExecutorService, δημιουργία νέας δεξαμενής για κάθε λειτουργία, πολύ μεγάλη δεξαμενή, αδιέξοδο μεταξύ εργασιών, χρήση CachedThreadPool στο Android.

Αδιέξοδο (Deadlock) στο Thread Pool

Αδιέξοδο προκύπτει όταν μια εργασία στη δεξαμενή περιμένει το αποτέλεσμα μιας άλλης εργασίας από την ίδια δεξαμενή, αλλά όλα τα νήματα είναι απασχολημένα με αναμονή. Παράδειγμα: η εργασία Α στέλνει την εργασία Β στην ίδια δεξαμενή και καλεί future.get() — αν η δεξαμενή έχει εξαντληθεί, η εργασία Α περιμένει την εργασία Β και η εργασία Β δεν μπορεί να εκτελεστεί επειδή δεν υπάρχουν ελεύθερα νήματα. Λύση: χρησιμοποιήστε ξεχωριστές δεξαμενές για διαφορετικά επίπεδα εργασιών ή ασύγχρονη callback αντί για .get() αποκλεισμού.

// Αδιέξοδο (Deadlock) στο Thread Pool
val pool = Executors.newFixedThreadPool(1)

// Η εργασία Α περιμένει την εργασία Β — αδιέξοδο!
val futureA = pool.submit {
    // Αυτή η εργασία δεν θα εκτελεστεί ποτέ
    val futureB = pool.submit { 42 }
    futureB.get() // Μπλοκαρισμένο για πάντα
}

// Διόρθωση: ξεχωριστές δεξαμενές
val workerPool = Executors.newFixedThreadPool(2)
val callbackPool = Executors.newSingleThreadExecutor()

workerPool.submit {
    callbackPool.submit {
        // Εκτελείται σε ξεχωριστή δεξαμενή — αδιέξοδο αδύνατο
    }
}

// Ή χρησιμοποιήστε CompletableFuture
workerPool.submit {
    CompletableFuture
        .supplyAsync { 42 }
        .thenAccept { result ->
            println(result)
        }
}

Μη τερματισμένη δεξαμενή και διαρροές

Το ExecutorService που δημιουργήθηκε στο Activity πρέπει να τερματιστεί στο onDestroy(). Εάν δεν γίνει αυτό, τα νήματα θα παραμείνουν στη μνήμη ακόμη και μετά την καταστροφή του Activity. Λύση: αποθηκεύστε τη δεξαμενή στο εύρος Application ή ViewModel, όχι στο Activity. Για coroutine, χρησιμοποιήστε viewModelScope ή lifecycleScope. Εάν η δεξαμενή δημιουργήθηκε μέσα στο Activity, φροντίστε να καλέσετε το pool.shutdown() στο onDestroy(). Για δοκιμή, χρησιμοποιήστε es.shutdownNow() για άμεσο τερματισμό.