Kodu paralel (ana olmayan) bir iş parçacığında nasıl çalıştırırsınız?

Android'de kodun paralel yürütülmesi için, ana (UI) akışı engellemeden uygulamanın yanıt verebilirliğini koruyan çeşitli mekanizmalar kullanılmaktadır.

Android'in yerleşik araçları:

1. Thread: Yeni bir akış oluşturmak için temel sınıf.

   new Thread(new Runnable() {
       @Override
       public void run() {
           // Paralel akışta çalıştırılacak kod
       }
   }).start();
   

   Dezavantaj: Manuel akış yönetimi, yaşam döngüsü sorunlarına ve bellek sızıntılarına yol açabilir.

2. AsyncTask (Kullanımdan kaldırıldı): Paralel akışlarla çalışma ve UI akışıyla etkileşimi kolaylaştırır.

   private static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
       @Override
       protected Void doInBackground(Void... params) {
           // Arka planda çalıştırılacak kod
           return null;
       }
   
       @Override
       protected void onPostExecute(Void result) {
           // doInBackground sonrası UI akışında çalışma
       }
   }
   // Kullanım: new MyAsyncTask().execute();
   

   Dezavantajlar: Kullanımdan kaldırıldı, sınırlamaları ve yaşam döngüsü yönetiminde zorlukları var.

3. Handler ve Looper: Mesaj işleme döngüleri ile akışlar oluşturmayı sağlar.

   HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
   handlerThread.start();
   Handler handler = new Handler(handlerThread.getLooper());
   handler.post(new Runnable() {
       @Override
       public void run() {
           // Looper ile akışta çalıştırılacak kod
       }
   });
   

   Avantaj: Tekrarlayan görevler veya asenkron olayların işlenmesi için uygundur.

4. ExecutorService / ThreadPoolExecutor: Akış havuzları sağlar, her görev için yeni Thread oluşturmaktan daha etkilidir.

   ExecutorService executor = Executors.newSingleThreadExecutor(); // veya newCachedThreadPool(), newFixedThreadPool(N)
   executor.execute(new Runnable() {
       @Override
       public void run() {
           // Havuzdaki akışta çalıştırılacak kod
       }
   });
   // İşlem tamamlandığında executor.shutdown() çağrılmalı
   

   Avantajlar: Akışların oluşturulmasını ve yeniden kullanılmasını yönetir, maliyetleri azaltır.

Modern yaklaşımlar:

5. Kotlin Coroutines: Hafif akışlar, daha basit ve okunabilir asenkron programlama sağlar.

   import kotlinx.coroutines.*
   
   // Arka plan havuzunda coroutine başlatma (arka plan akışına benzer)
   GlobalScope.launch(Dispatchers.Default) {
       // Arka planda çalıştırılacak kod
   }
   
   // IO işlemleri için coroutine başlatma
   GlobalScope.launch(Dispatchers.IO) {
       // Ağ, dosya vb. IO işlemleri
   }
   
   // UI güncellemesi için ana akışa geçiş
   GlobalScope.launch(Dispatchers.Default) {
       // Arka plan hesaplamaları
       withContext(Dispatchers.Main) {
           // UI güncellemesi
       }
   }
   

   Avantajlar: Kod okunabilirliği artar, kaynak kullanımı daha verimli, iptal yönetimi kolay, yapılandırılmış eşzamanlılık.

6. RxJava / RxKotlin: Gözlemlenebilir veri akışlarına dayalı reaktif programlama.

   import io.reactivex.rxjava3.core.Observable;
   import io.reactivex.rxjava3.schedulers.Schedulers;
   
   Observable.just("Bir sonuç")
       .subscribeOn(Schedulers.io()) // IO akışında çalıştır
       .observeOn(AndroidSchedulers.mainThread()) // UI akışında gözlemle
       .subscribe(/* Sonuç işleme */);
   

   Avantajlar: Asenkron olaylar ve veri dönüşümleri için güçlü araç, ancak öğrenme eğrisi daha dik.

WorkManager Kütüphanesi:

7. WorkManager: Background görevlerin güvenilir şekilde yürütülmesini sağlayan Architecture Components bileşeni, uygulama kapalı olsa veya cihaz yeniden başlatılsa bile.

   import androidx.work.*
   import java.util.concurrent.TimeUnit
   
   class MyWorker(appContext: Context, workerParams: WorkerParameters): Worker(appContext, workerParams) {
       override fun doWork(): Result {
           // Arka planda çalıştırılacak kod
           return Result.success() // veya Result.failure(), Result.retry()
       }
   }
   
   // Görev isteği oluşturma
   val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
       .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()) // Opsiyonel kısıtlamalar
       .build()
   
   // Görevi kuyruğa ekleme
   WorkManager.getInstance(context).enqueue(workRequest)
   

   Avantajlar: Güvence altına alınmış yürütme, ağ tipi ve pil durumu gibi kısıtlamaları destekler, iptal yönetimi, ertelenmiş yürütme ve tekrarlar.

Belirli bir yöntemi seçmek, görevin türüne, yaşam döngüsüne ve güvenilirlik gereksinimlerine bağlıdır. Modern Android uygulamaları için Kotlin Coroutines veya WorkManager kullanımı önerilir.