Qanday qilib kodni parallel (asosiy bo'lmagan) ipda bajarish mumkin?

Androidda kodni parallel bajarish uchun turli mexanizmlar ishlatiladi, ular asosiy (UI) oqimni bloklamaslik va ilovaning javob beruvchanligini saqlash imkonini beradi.

Androidning standart vositalari:

1. Thread: Yangi oqim yaratish uchun asosiy sinf.

   new Thread(new Runnable() {
       @Override
       public void run() {
           // Parallel oqimda bajariladigan kod
       }
   }).start();
   

   Kamchilik: Oqimlarni qo'lda boshqarish hayot aylanishi muammolariga va xotira oqishlariga olib kelishi mumkin.

2. AsyncTask (Eski): Parallel oqimlar bilan ishlashni va UI oqimi bilan muloqotni soddalashtiradi.

   private static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
       @Override
       protected Void doInBackground(Void... params) {
           // Fon oqimida bajariladigan kod
           return null;
       }
   
       @Override
       protected void onPostExecute(Void result) {
           // doInBackground tugagandan so'ng UI bilan ishlash
       }
   }
   // Foydalanish: new MyAsyncTask().execute();
   

   Kamchiliklar: Eski, cheklovlar va hayot aylanishini boshqarishda qiyinchiliklar mavjud.

3. Handler va Looper: Xabarlar bilan ishlash tsikllari bilan oqimlar yaratishga imkon beradi.

   HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
   handlerThread.start();
   Handler handler = new Handler(handlerThread.getLooper());
   handler.post(new Runnable() {
       @Override
       public void run() {
           // Looper bilan oqimda bajariladigan kod
       }
   });
   

   Afzallik: Takroriy vazifalarni bajarish yoki asinxron voqealarni qayta ishlash uchun qulay.

4. ExecutorService / ThreadPoolExecutor: Oqimlar havzasini taqdim etadi, bu har bir vazifa uchun yangi Thread yaratishdan ko'ra samaraliroq.

   ExecutorService executor = Executors.newSingleThreadExecutor(); // Yoki newCachedThreadPool(), newFixedThreadPool(N)
   executor.execute(new Runnable() {
       @Override
       public void run() {
           // Oqimda bajariladigan kod
       }
   });
   // Tugagach, executor.shutdown() ni chaqirishni unutmang
   

   Afzalliklar: Oqimlarni yaratish va qayta ishlatishni boshqaradi, xarajatlarni kamaytiradi.

Zamonaviy yondashuvlar:

5. Kotlin Coroutines: Yengil oqimlar, asinxron dasturlashni soddalashtiradigan va o'qilishi osonroq usul.

   import kotlinx.coroutines.*
   
   // Oqimlar havzasida korutina ishga tushirish (fon oqimi)
   GlobalScope.launch(Dispatchers.Default) {
       // Fon oqimida bajariladigan kod
   }
   
   // IO operatsiyalari uchun korutina ishga tushirish
   GlobalScope.launch(Dispatchers.IO) {
       // Tarmoq, fayllar bilan ishlash va hokazo
   }
   
   // UI ni yangilash uchun UI oqimiga o'tish
   GlobalScope.launch(Dispatchers.Default) {
       // Fon hisoblashlar
       withContext(Dispatchers.Main) {
           // UI ni yangilash
       }
   }
   

   Afzalliklar: Kodning o'qilishi yaxshilanadi, resurslardan samarali foydalanish, vazifalarni bekor qilishni boshqarish oson, strukturali raqobat.

6. RxJava / RxKotlin: Reaktiv dasturlash, kuzatuvchi oqimlar asosida.

   import io.reactivex.rxjava3.core.Observable;
   import io.reactivex.rxjava3.schedulers.Schedulers;
   
   Observable.just("Nimani natija")
       .subscribeOn(Schedulers.io()) // IO oqimida bajarish
       .observeOn(AndroidSchedulers.mainThread()) // UI oqimida kuzatish
       .subscribe(/* Natijani ishlash */);
   

   Afzalliklar: Asinxron voqealar bilan ishlash va ma'lumotlarni o'zgartirish uchun kuchli vosita, ammo kirish darajasi yuqori.

WorkManager kutubxonasi:

7. WorkManager: Background vazifalarni bajarish uchun tavsiya etilgan Architecture Components komponenti, hatto ilova yopilgan yoki qurilma qayta yuklangan bo'lsa ham.

   import androidx.work.*
   import java.util.concurrent.TimeUnit
   
   class MyWorker: Worker(appContext, workerParams) {
       override fun doWork(): Result {
           // Background vazifa bajarish kodi
           return Result.success() // yoki Result.failure(), Result.retry()
       }
   }
   
   // Vazifa so'rovini yaratish
   val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
       .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()) // Ixtiyoriy cheklovlar
       .build()
   
   // Vazifani navbatga qo'yish
   WorkManager.getInstance(context).enqueue(workRequest)
   

   Afzalliklar: Garantiyali bajarilish, cheklovlarni qo'llab-quvvatlash (tarmoq turi, batareya zaryadi), bekor qilishni boshqarish, kechiktirilgan bajarish va takrorlash.

Aniq metodni tanlash vazifaning turiga, hayot tsikliga va bajarilish ishonchliligiga bog'liq. Ko'pchilik zamonaviy Android ilovalar uchun Kotlin Coroutines yoki WorkManager tavsiya etiladi.