iOS'ta hangi çoklu işleme mekanizmaları kullanılıyor…

iOS'ta aşağıdaki temel çoklu görev mekanizmaları kullanılır:

Grand Central Dispatch (GCD):
- Yüksek seviyeli paralellik yönetim mekanizması.
- Görev kuyruklarına (dispatch queues) dayanır.
- Kod bloklarının asenkron veya senkron olarak çalıştırılmasına izin verir.
- Sıralı (serial) ve eşzamanlı (concurrent) kuyruklar ile küresel (global) eşzamanlı kuyruklar ayırt edilir.
- Çoğu çoklu görev görevi için tercih edilen yöntem.
```
// GCD kullanarak arka planda görev yürütme
DispatchQueue.global(qos: .userInitiated).async {
    // Uzun süren işlem
    DispatchQueue.main.async {
        // Ana thread'de UI güncellemesi
    }
}
```
İşlemler ve İşlem Kuyrukları:
- Nesne yönelimli görev yönetimi yaklaşımı.
- Operation - bağımsız bir görevi temsil eden soyut sınıf.
- OperationQueue - Operation nesnelerinin yürütülmesini yöneten kuyruk.
- Bağımlılıkları, öncelikleri, iptalleri ve kalıtımı destekler.
- GCD'den daha esnek ve karmaşık bir mekanizma, daha karmaşık görev yönetimi senaryoları için uygundur.
```
// Kuyruğa işlem ekleme
let operation = BlockOperation {
    // İşlem görevi
    print("İşlem yürütüldü")
}

let operationQueue = OperationQueue()
operationQueue.addOperation(operation)
```
İşlemler (Pthreads):
- Düşük seviyeli mekanizma, sistemle daha yakındır.
- POSIX Threads API kullanılarak doğrudan thread yönetimi.
- Thread yaşam döngüsünün manuel yönetimini gerektirir (oluşturma, sonlandırma, senkronizasyon).
- GCD ve İşlemler'e kıyasla daha karmaşık ve hata yapmaya açık (örneğin, yarış koşulları).
- Genellikle belirli ve düşük seviyeli senaryolarda kullanılır, daha yüksek seviyeli API'ler yeterli değilse. Modern iOS geliştirmede nadiren kullanılır.
```
// Pthreads kullanarak thread oluşturma örneği
// (Swift'te kullanımı wrapper veya C interop gerektirir)

/*
#include <pthread.h>

void* thread_function(void* arg) {
    // Thread kodu
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    pthread_join(thread, NULL); // Thread'in bitmesini bekle
    return 0;
}
*/
```
Actors (Swift Concurrency):
- Swift 5.5 ile tanıtılan yeni mekanizma.
- Çoklu iş ortamında değiştirilebilir durumla güvenli çalışma.
- Duruma erişimi yalnızca bir görevin aynı anda yapmasını sağlar, yarış koşullarını önler.
- Asenkron fonksiyonlar (async/await) ile kullanılır.
- Swift'te çoklu iş ortamlarında durumu yönetmek için önerilen yaklaşım.
```
actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        value
    }
}

// Actor kullanımı
// let counter = Counter()
// await counter.increment()
// let currentValue = await counter.getValue()
```

Temel mekanizmaların karşılaştırmalı tablosu:

Mekanizma	Soyutlama Seviyesi	Yönetim	Güvenlik (yarış koşulları)	Kullanım
GCD	Yüksek	Görev kuyrukları (kod blokları)	Orta*	Genel görevler, asenkron işlemler
İşlemler & Kuyruklar	Orta	Görev nesneleri (`Operation`)	Orta*	Daha karmaşık görevler, bağımlılıklar
Threads (Pthreads)	Düşük	Doğrudan thread yönetimi	Düşük (manuel senkronizasyon)	Belirli, düşük seviyeli görevler (nadiren)
Actors (Swift Concurrency)	Yüksek**	Durum izolasyonu (`actor`)	Yüksek	Durum yönetimi ve değişken kodda güvenli çalışma

** GCD ve İşlemlerin güvenliği, erişimlerin doğru senkronizasyonuna bağlıdır (örneğin, DispatchQueue.sync, NSLock, semaforlar kullanılarak). ** Güvenli durumu yönetmek için yüksek seviye, asenkron sözdizimi ile entegre edilmiştir.

Modern iOS geliştirmede, Pthreads ile doğrudan thread yönetiminden kaçınılarak GCD, İşlemler ve Aktörler kullanılması önerilir, gerekirse.

iOS'ta hangi çoklu işleme mekanizmaları kullanılıyor?