Ինչպես կատարել կոդը պառլել (ոչ գլխավոր) թելում?

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: