როგორ შევქმნათ ორი ნაკადი Dart-ში Flutter-ის კონტექსტში?

Dart/Flutter-შე დამოუკიდებელი ნაკადების შექმნისთვის გამოიყენება იზოლატები (Isolates). ისინი წარმოადგენენ ცალკეულ დავალებებს საკუთარი მეხსიერების სივრცით, რაც თავიდან აცილებს კონკურენტული წვდომის პრობლემებს მონაცემებზე და მთავარ ნაკადზე (UI ნაკადზე) დაბლოკვას.

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

1. Isolate.spawn(): ყველაზე დაბალი დონეზე იზოლატის შექმნის მეთოდი. საჭიროებს ფუნქციის ან სტატიკური მეთოდის გადაცემას ახალი იზოლატისთვის და პორტს შეტყობინებების გასაცვლელად.

   import 'dart:isolate';
   
   // ფუნქცია, რომელიც შესრულდება იზოლატში
   void isolateEntry(SendPort sendPort) {
     // რაიმე გრძელი ოპერაციის შესრულება
     int result = 0;
     for (int i = 0; i < 1000000000; i++) {
       result += i;
     }
     // შედეგის დაბრუნება მთავარ იზოლატს
     sendPort.send(result);
   }
   
   void main() async {
     ReceivePort receivePort = ReceivePort();
     // ახალი იზოლატის შექმნა
     Isolate isolate = await Isolate.spawn(isolateEntry, receivePort.sendPort);
   
     // მესიჯების მოსმენა იზოლატიდან
     receivePort.listen((message) {
       print('იზოლატიდან შედეგი: $message');
       // იზოლატის დახურვა მესიჯის მიღების შემდეგ
       isolate.kill();
     });
   
     print('ძირითადი ნაკადი აგრძელებს მუშაობას...');
   }
   

2. compute(): flutter/foundation პაკეტში არსებული მარტივი ფუნქცია, რომელიც იყენებს Isolate.spawn()-ს უკან. იდეალურია მარტივი ფონური დავალებებისთვის, რომლებიც არ საჭიროებს რთულ ურთიერთქმედებას იზოლატთან.

   import 'package:flutter/foundation.dart';
   
   // ფუნქცია, რომელიც შესრულდება compute-ის გამოყენებით
   int heavyComputation(int limit) {
     int result = 0;
     for (int i = 0; i < limit; i++) {
       result += i;
     }
     return result;
   }
   
   void main() async {
     print('მძიმე გამოთვლების დაწყება ფონზე...');
     // ფუნქციის შესრულება ცალკეულ იზოლატში
     int result = await compute(heavyComputation, 1000000000);
     print('გამოთვლების შედეგი: $result');
     print('ძირითადი ნაკადი აგრძელებს მუშაობას გამოთვლების შემდეგ.');
   }
   

3. Isolate.spawnUri(): გამოიყენება კოდის განსახორციელებლად ცალკეულ ფაილში dart ახალ იზოლატში.

ინტერაქცია იზოლატებს შორის:

იზოლატები ცვლიან მონაცემებს მხოლოდ შეტყობინებების გადაცემით SendPort და ReceivePort-ის მაგალითებით. ეს ოპერაციები ატომურია და არ საჭიროებს ბლოკირებებს ან სხვა სინქრონიზაციის მექანიზმებს.

• SendPort: გამოიყენება შეტყობინებების გაგზავნისთვის ერთ იზოლატიდან მეორეში.
• ReceivePort: გამოიყენება შემომავალი შეტყობინებების მოსასმენად.

მონაცემების გადაცემისას, ობიექტები უნდა იყოს "გადაცემადი" (transferable), რაც მოიცავს:

• მარტივ ტიპებს (int, double, String, bool)
• სია და მეპები, რომელთაც შეიცავს გადაცემად შესაბამისი ტიპები
• ზოგიერთი Flutter-ის სპეციფიკური ტიპი, რომლებიც სერილიზებადი შეიძლება იყოს

გადაცემადი არავინა ობიექტები იკოპირებს, და მათი შემდგომი ცვლილებები ერთ იზოლატში არ აისახება მეორეში.

ძირითადი მახასიათებლები:

• იზოლატებს შეუძლიათ პირდაპირ არ მიაწვდინონ ერთმანეთს მეხსიერება.
• იზოლატებს არ აქვთ წვდომა საერთო მდგომარეობაზე, მათ შორის ცვლადებზე, კლასებზე და ვიჯეტებზე ძირითადი იზოლატში (UI ნაკადში).
• კომუნიკაცია იზოლატებს შორის ხდება ასინქრონულად.
• Flutter-ში იზოლატებთან მუშაობისას მნიშვნელოვანია მათი სიცოცხლის ციკლის სწორად მართვა (მაგალითად, isolate.kill()-ის გამოყენება საჭიროების შემთხვევაში).

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