როგორ განვახორციელოთ კოდი პარალელურ (მთავარ არა) ნაკადში?

Android-ში კოდის პარალელურად შესრულებისთვის გამოიყენება სხვადასხვა მექანიზმები, რომლებიც საშუალებას აძლევენ არ ბლოკავდნენ მთავარი (UI) ნაკადს და შეინარჩუნონ აპლიკაციის რეაგირებისუნარიანობა.

Android-ის სტანდარტული საშუალებები:

1. Thread: ახალი ნაკადის შექმნის ძირითადი კლასი.

   new Thread(new Runnable() {
       @Override
       public void run() {
           // კოდი პარალელურ ნაკადში შესრულებისთვის
       }
   }).start();
   

   ნაკლოვანება: ნაკადების ხელით მართვა შეიძლება გამოიწვიოს ციკლის პრობლემები და მეხსიერების ნაკადები.

2. AsyncTask (ძველი): გამარტივებული მუშაობა პარალელურ ნაკადებთან და UI ნაკადთან ურთიერთობაში.

   private static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
       @Override
       protected Void doInBackground(Void... params) {
           // კოდი ფონურ ნაკადში
           return null;
       }
   
       @Override
       protected void onPostExecute(Void result) {
           // UI ნაკადში მუშაობა
       }
   }
   // გამოყენება: new MyAsyncTask().execute();
   

   ნაკლოვანებები: მოძველებულია, აქვს შეზღუდვები და სირთულეები ციკლის მართვაში.

3. Handler და Looper: საშუალებას აძლევენ შექმნათ შეტყობინებების ციკლებით სამუშაო ნაკადები.

   HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
   handlerThread.start();
   Handler handler = new Handler(handlerThread.getLooper());
   handler.post(new Runnable() {
       @Override
       public void run() {
           // კოდი Looper-ით ნაკადში შესრულებისთვის
       }
   });
   

   უპირატესობა: სასარგებლოა განმეორებადი დავალებების ან ასინქრონული მოვლენების დამუშავებისთვის.

4. ExecutorService / ThreadPoolExecutor: უზრუნველყოფს ნაკადების პულებს, რაც უფრო ეფექტურია, ვიდრე ახალი Thread შექმნა თითოეულ დავალებაზე.

   ExecutorService executor = Executors.newSingleThreadExecutor(); // ან newCachedThreadPool(), newFixedThreadPool(N)
   executor.execute(new Runnable() {
       @Override
       public void run() {
           // კოდი პულიდან ნაკადში შესრულებისთვის
       }
   });
   // არ დაგავიწყდეთ executor.shutdown() დასრულებისას
   

   უპირატესობა: მართავს ნაკადების შექმნას და გამოყენებას, ამცირებს ხარჯებს.

ახლანდელი მიდგომები:

5. Kotlin Coroutines: მსუბუქი ნაკადები, რომლებიც უზრუნველყოფენ უფრო მარტივ და კითხულადი გზას ასინქრონული პროგრამირებისათვის.

   import kotlinx.coroutines.*
   
   // კორუტინას გაშვება ნაკადის პულში (ფონური ნაკადი)
   GlobalScope.launch(Dispatchers.Default) {
       // კოდი ფონურ ნაკადში
   }
   
   // გაშვება IO ოპერაციებისათვის
   GlobalScope.launch(Dispatchers.IO) {
       // კოდი IO ოპერაციების შესრულებისთვის
   }
   
   // გადართვა UI ნაკადზე მომხმარებლის ინტერფეისის განახლებისთვის
   GlobalScope.launch(Dispatchers.Default) {
       // ფონური გამოთვლები
       withContext(Dispatchers.Main) {
           // UI განახლება
       }
   }
   

   უპირატესობა: კოდის კითხულადი გახადება, რესურსების ეფექტიანი გამოყენება, დავალებების გაუქმების მართვა, სტრუქტურირებული კონკურენცია.

6. RxJava / RxKotlin: რეაქტიული პროგრამირება, დაფუძნებული თვალსაზრისით ნაკადებზე.

   import io.reactivex.rxjava3.core.Observable;
   import io.reactivex.rxjava3.schedulers.Schedulers;
   
   Observable.just("რაოდენობრივი შედეგი")
       .subscribeOn(Schedulers.io()) // შესრულება IO ნაკადში
       .observeOn(AndroidSchedulers.mainThread()) // დაკვირვება UI ნაკადზე
       .subscribe(/* შედეგის დამუშავება */);
   

   უპირატესობა: ძლიერი ინსტრუმენტი ასინქრონული მოვლენების და მონაცემთა გარდაქმნისთვის, მაგრამ მაღალი სავალდებულო ზღვარი აქვს.

WorkManager ბიბლიოთეკა:

7. WorkManager: რეკომენდებული კომპონენტი Architecture Components-დან, რომელიც უზრუნველყოფს ფონური დავალებების შესრულებას, მიუხედავად აპლიკაციის დახურვისა ან მოწყობილობის გადატვირთვისა.

   import androidx.work.*
   import java.util.concurrent.TimeUnit
   
   class MyWorker: Worker(appContext, workerParams) {
       override fun doWork(): Result {
           // კოდი ფონურ დავალებაზე
           return Result.success() // ან Result.failure(), Result.retry()
       }
   }
   
   // დავალების მოთხოვნის შექმნა
   val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
       .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()) // შეზღუდვები
       .build()
   
   // დავალების რიგში განთავსება
   WorkManager.getInstance(context).enqueue(workRequest)
   

   უპირატესობა: გარანტირებული შესრულება, შეზღუდვების მხარდაჭერა (საკავშირო ტიპი, ბატარეის დატენვა), გაუქმების მართვა, დაგეგმილი შესრულება და გამეორებები.

შესარჩევი მეთოდი კოდის შესრულებისთვის პარალელურ ნაკადში დამოკიდებულია დავალების ტიპზე, მისი სიცოცხლის ციკლზე და სანდოობის მოთხოვნებზე. თანამედროვე Android პროგრამებისთვის რეკომენდებულია Kotlin Coroutines ან WorkManager-ის გამოყენება.