I’m trying to get some idea/intuition about how Dart’s async/await work.

Here is a simple Dart program where there is:

• a producer function adding strings to pipe (a List<String>).
• a consumer function reading pipe every 100ms, removing any strings.

Both functions have been made to run concurrently as ‘tasks on the event loop’ by ‘futurizing’ (what’s the correct word?) them. There is no need for synchronizing access to the pipe, but the consumer function must call Future.delayed() to yield the CPU so that the producer is able to run.

Is there a way to perform waiting on pipe until it is not-empty rather than checking every 100ms? Am I supposed to use a Dart stream for that?

import 'dart:async';
import 'dart:math';

final pipe = <String>[];
final rand = Random();

String now() {
  return '${DateTime.now()}';
}

Future producer() async {
  print('Producer starts at ${now()}');
  for (int i = 0; i < 5; i++) {
    int delay_ms = 500 + rand.nextInt(3000);
    print('Producer delaying by $delay_ms ms ...');
    await Future.delayed(Duration(milliseconds: delay_ms));
    final payload = 'payload $i';
    pipe.add(payload);
    print("Producer produced '$payload' at ${now()}");
  }
  pipe.add('DONE');
  print('Producer ends at ${now()}');
}

Future consumer() async {
  print('Consumer starts at ${now()}');
  String? received;
  while (received != 'DONE') {
    // do nothing for 100ms, giving the producer CPU time
    await Future.delayed(const Duration(milliseconds: 100));
    received = null;
    // --- is there a better way?? ---
    while (pipe.isNotEmpty && received != 'DONE') {
      received = pipe.removeAt(0);
      print("Consumer received '$received' at ${now()}");
    }
  }
  print('Consumer ends at ${now()}');
}


Future<void> main() async {
  print('main(): Starting');

  final Future producerFuture = producer().then((_) {
    print('Producer finished');
  });

  print('main(): Producer is running');

  final Future consumerFuture = consumer().then((_) {
    print('Consumer finished');
  });

  print('main(): Consumer is running');

  final Future commonFuture = Future.wait([producerFuture, consumerFuture]);

  await commonFuture;

  print('main(): Done');
}

An example run might be:

main(): Starting
Producer starts at 2024-05-28 15:39:38.021731
Producer delaying by 2092 ms ...
main(): Producer is running
Consumer starts at 2024-05-28 15:39:38.040345
main(): Consumer is running
Producer produced 'payload 0' at 2024-05-28 15:39:40.125837
Producer delaying by 2526 ms ...
Consumer received 'payload 0' at 2024-05-28 15:39:40.170401
Producer produced 'payload 1' at 2024-05-28 15:39:42.652816
Producer delaying by 2167 ms ...
Consumer received 'payload 1' at 2024-05-28 15:39:42.695814
Producer produced 'payload 2' at 2024-05-28 15:39:44.820820
Producer delaying by 3091 ms ...
Consumer received 'payload 2' at 2024-05-28 15:39:44.917827
Producer produced 'payload 3' at 2024-05-28 15:39:47.912795
Producer delaying by 2285 ms ...
Consumer received 'payload 3' at 2024-05-28 15:39:47.947775
Producer produced 'payload 4' at 2024-05-28 15:39:50.198882
Producer ends at 2024-05-28 15:39:50.199027
Producer finished
Consumer received 'payload 4' at 2024-05-28 15:39:50.271304
Consumer received 'DONE' at 2024-05-28 15:39:50.271424
Consumer ends at 2024-05-28 15:39:50.271494
Consumer finished
main(): Done