Hello, Habr! I present to you the translation of the article "Futures - Isolates - Event Loop" by Didier Boelens on asynchrony and multithreading in Dart
(and Flutter
in particular).
TLDR: , . Event Loop, Future async/await (, JavaScript), otlin, , . , .
And about the translation of the terms. In spoken languagewe I say "streams", "trades", "futures", etc., while in print these terms look strange and clumsy.
At the same time, it Stream
is a Stream, and Thread
- a Stream. Context in this case does not always save. The same Isolate, for my taste, sounds normal in Russian, so somewhere I use the spelling in Cyrillic, and somewhere in the original.
Here and there in brackets after Russian words their English original, sometimes vice versa.
Introduction
Recently, I often get questions relating to the concepts of Future
, async
, await
, Isolate
and parallel execution of code.
In addition, some developers have problems understanding the sequence of execution of their code.
I decided to seize the opportunity and devote an article to these issues. At the same time, I will try to get rid of the confusion associated mainly with the concepts of
and
.
Dart
- single threaded language
, Dart
โ Flutter
Dart
.
Dart
. . , .
, ( ), , .
void myBigLoop(){
for (int i = 0; i < 1000000; i++){
_doSomethingSynchronously();
}
}
, myBigLoop()
. , - ,
, .
Dart
Dart
, , Event Loop
.
Flutter
- ( Dart
-), โ Thread
, โ
(Isolate
). , .
, :
- (
Queues
) MicroTask
()
Event
(), FIFO
(.: first in first out, .. ,
, ), main()
,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
, :
, , 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
:
print('Before the Future')
(){print('Running the Future');}
Event
print('After the Future')
Event Loop
2- ,
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 experiences lags), .
, :
- ,
( ) - ,
, โ Event Loop
Futures
- ,
, โ
, , , Futures
( async
-) โ Futures
Event Loop
"" . , ( - , ).
, Future
โ , .
:
- JSON, (HttpRequest),
=> compute
- : =>
- ( ..) =>
- :
, , .
, , Event Loop
.
It is also important not to forget that Flutter
( Dart
) is single-threaded, therefore, in order to satisfy users, developers must be sure that the application will work as smoothly as possible. Futures
and
- powerful tools to help achieve this goal.
Good luck