Hello, everyone!
I recently spent more than 2 days trying to figure out the difference between all Future named constructors. I'll omit .delayed as it's pretty much the same as a normal Future with a delay in execution.
Future()
Future.value()
Future.sync()
Future.microtask()
I have created this example:
import 'dart:async';
void main(List<String> arguments) {
print('Start');
Future(() => 1).then(print);
Future(() => Future(() => 2)).then(print);
Future.value(3).then(print);
Future.value(Future(() => 4)).then(print);
Future.sync(() => 5).then(print);
Future.sync(() => Future(() => 6)).then(print);
Future.microtask(() => 7).then(print);
Future.microtask(() => Future(() => 8)).then(print);
Future(() => 9).then(print);
Future(() => Future(() => 10)).then(print);
print('End');
}
The output for it is
Start
End
3
5
7
1
4
6
9
8
2
10
Now, if you were like me, and you didn't understand for 2 days straight why was this output generated, I think I finally understood why, and I will explain the though process I've been going through. Hopefully, somebody from this subreddit will be able to confirm on whether I'm correct or not. Therefore, here we go with the explanation.
At the beginning I like to think that there's an event list containing all lines of code the isolate scanned from my main.dart file. Therefore, this list will look something like this:
print('End');
Future(() => Future(() => 10)).then(print);
Future(() => 9).then(print);
Future.microtask(() => Future(() => 8)).then(print);
Future.microtask(() => 7).then(print);
Future.sync(() => Future(() => 6)).then(print);
Future.sync(() => 5).then(print);
Future.value(Future(() => 4)).then(print);
Future.value(3).then(print);
Future(() => Future(() => 2)).then(print);
Future(() => 1).then(print);
print('Start');
Imagine that the scanner is at the end, ready to scan the first element, which is Start. More like a FIFO structure. Now, the isolate will assign each of these lines of code to either the EVENT QUEUE or the MICROTASK QUEUE.
This task has been probably the hardest for me to understand.
So, currently the EVENT QUEUE, MICROTASK QUEUE and output sequence are all empty.
EVENT QUEUE:
MICROTASK QUEUE:
PRINT:
So, we'll process the first line, which is print('Start'), a synchronous task that we can execute right away, therefore the trio looks like this.
EVENT QUEUE:
MICROTASK QUEUE:
PRINT: Start
Then, we move over to the next line, which is Future(() => 1).then(print);
Now, from what I understood, this Future is going to complete with a value of () => 1, therefore it is actually going to put the () => 1 into the event queue. As a result, the trio will look like this after this step.
EVENT QUEUE: () => 1
MICROTASK QUEUE:
PRINT: Start
Moving on, the next line is *Future(() => Future(() => 2)).then(print);*Similar to the previous step, this time we're going to put () => Future(() => 2)) to the event queue.For simplicity I'll rename () => 1 to 1 and () => Future(() => 2)) to F(2).
Now, the trio is going to look like this:
EVENT QUEUE: F(2), 1
MICROTASK QUEUE:
PRINT: Start
Now, onto the next one, we have *Future.value(3).then(print);*From what I understood, and what I saw from the docs:
Future.value(x)
x is not future => x will be set as a new microtask event into the microtask queue
x is Future => x will be set as a new event into the event queue ( since Future.value(x) = Future (() => x) in this case, and it's like processing F(x) at the current step, therefore, we'll end up in placing x on the event queue)
As a result, in my case, I would set 3 (actually print(3)) as a microtask event, therefore the new trio looks like this:
EVENT QUEUE: F(2), 1
MICROTASK QUEUE: 3
PRINT: Start
Now, for the next line Future.value(Future(() => 4)).then(print); the argument sent to the Future.value() constructor is actually another future, so it falls back to the first option above. As a result, we'll set 4 as a new event into the event queue. This is because Future.value(Future(() => 4) is treated like Future(() => 4) by the event loop, therefore 4 will come later on the event queue. The trio looks like this right now.
EVENT QUEUE: 4, F(2), 1
MICROTASK QUEUE: 3
PRINT: Start
Moving on, we have the Future.sync(() => 5).then(print); line of code. From the docs, I actually read that:
x is non-future => Future.value(x) => Future.sync(() => x), and as a result of this, we'll place 5 as a new microtask event on the microtask queue. Therefore, the trio will look like this now.
EVENT QUEUE: 4, F(2), 1
MICROTASK QUEUE: 5, 3
PRINT: Start
Onto the next line, Future.sync(() => Future(() => 6)).then(print); , from the docs I saw that in this case,
x is Future => Future.sync(() => x) is equal to Future(() => x). As a result, we'll treat it just like a normal Future, and place it's complete value that's going to come on later on the event queue. The trio looks like this right now:
EVENT QUEUE: 6, 4, F(2), 1
MICROTASK QUEUE: 5, 3
PRINT: Start
The next line is Future.microtask(() => 7).then(print); From the docs I understood that this uses the scheduleMicrotask() function to place 7 on the microtask queue. As a result, the trio will result in this:
EVENT QUEUE: 6, 4, F(2), 1
MICROTASK QUEUE: 7, 5, 3
PRINT: Start
However, the big surprise comes for the next line: *Future.microtask(() => Future(() => 8)).then(print);*In this case, even though the parameter is a Future, it's still used in a scheduleMicrotask() function, therefore the F(8) will be placed on the Microtask Queue this time, and the trio will look like this.
EVENT QUEUE: 6, 4, F(2), 1
MICROTASK QUEUE: F(8), 7, 5, 3
PRINT: Start
The next two lines
Future(() => Future(() => 10)).then(print);
Future(() => 9).then(print);
are directly places as new events into the event queue, are they're normal futures. The trio will therefore look like this:
EVENT QUEUE: F(10), 9, 6, 4, F(2), 1
MICROTASK QUEUE: F(8), 7, 5, 3
PRINT: Start
And we arrive to process the final line, which can be tackled in a sync manner, therefore we will print End, the trio after we process every line of code looks like this.
EVENT QUEUE: F(10), 9, 6, 4, F(2), 1
MICROTASK QUEUE: F(8), 7, 5, 3
PRINT: Start End
Now, as I learned, Dart is a single thread language, therefore, the event loop can't accept both of these queues simultaneously. The microtask queue has priority. Therefore, we'll start by processing the microtask events.
We'll go with 3, 5, 7 and print them.Then, we'll take event F(8) which is a Future. As a result, we'll place 8 at the end of the event queue, since that's where all normal Futures are enqueued. The trio will, therefore look like this now:
EVENT QUEUE: 8, F(10), 9, 6, 4, F(2), 1
MICROTASK QUEUE:
PRINT: Start End 3 5 7
The microtask queue is empty now, so the event loop can move over to processing the events from the event queue.
As a result, it processes 1, which prints 1.Then it moves to F(2) which is going to add 2 at the end of the event queueThen it moves to 4 which is going to print 4Then it moves to 6 which is going to print 6Then it moves to 9 which is going to print 9Then it moves to F(10) which is going to add 10 at the end of the event queueThen it moves to 8 which is going to print 8
As a result the trio looks like this right now:
EVENT QUEUE: 10 2
MICROTASK QUEUE:
PRINT: Start End 3 5 7 1 4 6 9 8
In the end, there are only two events left on the event queue, and the event loop processes them one at a time, printing their values. This is why at the end, the trio with the output looks like this:
EVENT QUEUE:
MICROTASK QUEUE:
PRINT: Start End 3 5 7 1 4 6 9 8 2 10
I would really appreciate any feedback on how I tackled this entire problem as I spent too much time on it. I want to know if I'm correct in how I set up the queues and solved the problem.Thank you!
