हेलो, हेब्र! मैं आपके लिए डिडिएर बोएलेन्स के लेख "फ्यूचर्स - आइसोलेट्स - इवेंट लूप" का अनुवाद अतुल्यकालिक और Dart( Flutterविशेष रूप से) में और बहु-प्रसार पर प्रस्तुत करता हूं ।

TLDR:  ,        .       Event Loop, Future  async/await (,  JavaScript),   otlin,  ,       . ,        .

और शर्तों के अनुवाद के बारे में। बोली जाने वाली भाषा मेंहम मैं कहता हूं कि "धारा", "व्यापार", "वायदा", आदि, जबकि प्रिंट में ये शब्द अजीब और अनाड़ी लगते हैं।

उसी समय, यह Streamएक स्ट्रीम है, और Thread- एक स्ट्रीम। इस मामले में संदर्भ हमेशा नहीं बचा है। वही आइसोलेट, मेरे स्वाद के लिए, रूसी में सामान्य लगता है, इसलिए कहीं मैं सिरिलिक में वर्तनी का उपयोग करता हूं, और कहीं मूल में।

यहाँ और वहाँ कोष्ठक में रूसी शब्दों के बाद उनके अंग्रेजी मूल, कभी-कभी इसके विपरीत।

परिचय

हाल ही में, मैं अक्सर की अवधारणाओं से संबंधित प्रश्नों मिल Future, async, await, Isolateऔर कोड के समानांतर निष्पादन।

इसके अलावा, कुछ डेवलपर्स को अपने कोड के निष्पादन के अनुक्रम को समझने में समस्याएं हैं।

मैंने अवसर को जब्त करने और इन मुद्दों पर एक लेख समर्पित करने का फैसला किया। एक ही समय में, मैं की अवधारणाओं के साथ मुख्य रूप से जुड़े भ्रम से छुटकारा पाने की कोशिश करेंगे और ।

Dart - एकल पिरोया भाषा

, Dart — Flutter Dart.

Dart . . , .

, ( ), , .

void myBigLoop(){
    for (int i = 0; i < 1000000; i++){
        _doSomethingSynchronously();
    }
}

, myBigLoop() . , - , , .

Dart

Dart, , Event Loop.

Flutter- ( Dart-), — Thread, — (Isolate). , .

, :

1. (Queues) MicroTask ()
   Event (), FIFO (.: first in first out, .. ,
   , ),
2. main() ,
3. Event Loop ( )

,
Event Loop
, : MicroTask Event.

Event Loop "" ,
"". ,
Dart-, "" :

void eventLoop(){
    while (microTaskQueue.isNotEmpty){
        fetchFirstMicroTaskFromQueue();
        executeThisMicroTask();
        return;
    }

    if (eventQueue.isNotEmpty){
        fetchFirstEventFromQueue();
        executeThisEventRelatedCode();
    }
}

, MicroTask Event. ?

MicroTask

, , - , Event Loop.

. - , - :

MyResource myResource;

    ...

    void closeAndRelease() {
        scheduleMicroTask(_dispose);
        _close();
    }

    void _close(){
        // ,     
        //   
        ...
    }

    void _dispose(){
        // ,    
        //   ,  _close()
        // 
    }

-, , . , scheduleMicroTask() 7 . Event.

Event

, :

• ,
  
  • /
  • ...
• Future

, , Event.

, MicroTask , Event Loop Event .

, Futures Event.

Futures

Future , ( ) - .

, Future:

• , Dart
• , Future,
  Event
• Future (incomplete)
• , ( Future)

, Future Event,
Event Loop .

( ) then()
catchError() Future.

, :

void main(){
    print('Before the Future');
    Future((){
        print('Running the Future');
    }).then((_){
        print('Future is complete');
    });
    print('After the Future');
}

, :

Before the Future
After the Future
Running the Future
Future is complete

:

1. print('Before the Future')
2. (){print('Running the Future');} Event
3. print('After the Future')
4. Event Loop 2
5. , then()

:

Future , , Event Loop

(async)

async, Dart , :

• — Future
• , await,
• Future, await

, await , [ Future], .
Event Loop...

,
,

void main() async {
  methodA();
  await methodB();
  await methodC('main');
  methodD();
}

methodA(){
  print('A');
}

methodB() async {
  print('B start');
  await methodC('B');
  print('B end');
}

methodC(String from) async {
  print('C start from $from');

  Future((){                // <==     -  
    print('C running Future from $from');
  }).then((_){
    print('C end of Future from $from');
  });

  print('C end from $from');  
}

methodD(){
  print('D');
}

:

A
B start
C start from B
C end from B
B end
C start from main
C end from main
D
C running Future from B
C end of Future from B
C running Future from main
C end of Future from main

, methodC() . , , .

, methodD() , :

void main() async {
  methodA();
  await methodB();
  await methodC('main');
  methodD();  
}

methodA(){
  print('A');
}

methodB() async {
  print('B start');
  await methodC('B');
  print('B end');
}

methodC(String from) async {
  print('C start from $from');

  await Future((){                  // <==  
    print('C running Future from $from');
  }).then((_){
    print('C end of Future from $from');
  });
  print('C end from $from');  
}

methodD(){
  print('D');
}

:

A
B start
C start from B
C running Future from B
C end of Future from B
C end from B
B end
C start from main
C running Future from main
C end of Future from main
C end from main
D

, await Future methodC() .

:

, , Event Loop

. . method1 — method2? ?

void method1(){
  List<String> myArray = <String>['a','b','c'];
  print('before loop');
  myArray.forEach((String value) async {
    await delayedPrint(value);
  });  
  print('end of loop');
}

void method2() async {
  List<String> myArray = <String>['a','b','c'];
  print('before loop');
  for(int i=0; i<myArray.length; i++) {
    await delayedPrint(myArray[i]);
  }
  print('end of loop');
}

Future<void> delayedPrint(String value) async {
  await Future.delayed(Duration(seconds: 1));
  print('delayedPrint: $value');
}

: .

, method1 forEach() . , async ( Future). await, Event. , : print('end of loop'). Event Loop 3 .

method2, ( ) — .

, ,
Event Loop...

, Flutter? ?

, Isolate ().

, Isolate Dart Thread ().

Thread.

Flutter . .

Event Loop.

(MicroTask Event).

.

Dart.

, .

1.

() API, Dart.

1.1. 1:

, , , "" "" .

, , . SendPort ( , , /, ).

, "" " " , "". :

//
//   
//     
//    
//
SendPort newIsolateSendPort;

//
//   
//
Isolate newIsolate;

//
// ,    
//   
//
void callerCreateIsolate() async {
    //
    //   ReceivePort  
    // SendPort  
    //
    ReceivePort receivePort = ReceivePort();

    //
    //   
    //
    newIsolate = await Isolate.spawn(
        callbackFunction,
        receivePort.sendPort,
    );

    //
    //     ""
    //
    newIsolateSendPort = await receivePort.first;
}

//
//    
//
static void callbackFunction(SendPort callerSendPort){
    //
    //   SendPort   
    //  ""
    //
    ReceivePort newIsolateReceivePort = ReceivePort();

    //
    //  ""   SendPort  
    //
    callerSendPort.send(newIsolateReceivePort.sendPort);

    //
    //  
    //
}

:

1.2. 2:

, , :

//
// ,     
//   
// 
//     ""
//   String (   )
//
Future<String> sendReceive(String messageToBeSent) async {
    //
    //     
    //
    ReceivePort port = ReceivePort();

    //
    //   ,  
    //  ,   
    //   
    //
    newIsolateSendPort.send(
        CrossIsolatesMessage<String>(
            sender: port.sendPort,
            message: messageToBeSent,
        )
    );

    //
    //     
    //
    return port.first;
}

//
// Callback-    
//
static void callbackFunction(SendPort callerSendPort){
    //
    //   SendPort   
    //  
    //
    ReceivePort newIsolateReceivePort = ReceivePort();

    //
    //  ""   SendPort  
    //
    callerSendPort.send(newIsolateReceivePort.sendPort);

    //
    //  ,    ,
    //    
    //
    newIsolateReceivePort.listen((dynamic message){
        CrossIsolatesMessage incomingMessage = message as CrossIsolatesMessage;

        //
        //  
        //
        String newMessage = "complemented string " + incomingMessage.message;

        //
        //   
        //
        incomingMessage.sender.send(newMessage);
    });
}

//
//  
//
class CrossIsolatesMessage<T> {
    final SendPort sender;
    final T message;

    CrossIsolatesMessage({
        @required this.sender,
        this.message,
    });
}

1.3. 3:

, :

void dispose(){
    newIsolate?.kill(priority: Isolate.immediate);
    newIsolate = null;
}

1.4. — Stream

, "" "" (Streams). Single-Listener Stream ( ).

2. (One-shot computation)

, , Dart compute,

• ,
• — -
• .

: ( ).

3.

, ,

(Platform-Channel communication) (main isolate). , .

, ,
.

Future

, :

• (user friendliness)

, (user experiences lags), .

, :

1. ,
   ( )
2. ,
   , — Event Loop Futures
3. ,
   , —

, , , Futures ( async-) — Futures Event Loop "" . , ( - , ).

, Future — , .

• => Future
• =>

:

• JSON, (HttpRequest),
  => compute
• : =>
• ( ..) =>
• : , , .

, , Event Loop .

यह भी महत्वपूर्ण है कि इसे न भूलें Flutter( Dart) सिंगल-थ्रेडेड है, इसलिए, उपयोगकर्ताओं को संतुष्ट करने के लिए, डेवलपर्स को यह सुनिश्चित करना चाहिए कि एप्लिकेशन यथासंभव आसानी से काम करेगा। Futuresऔर - इस लक्ष्य को प्राप्त करने में मदद करने के लिए शक्तिशाली उपकरण।

सौभाग्य