Dart : how to prevent concurrent calls to async function

In Flutter, I have an async function that should not be called twice at the same time.

Here's a minimal example

class DatabaseHelper {

   Future<void> add100elements() async {
      // this functions queries a database and adds 100 elements from the db to a local list
       var elementsToAdd = await db.rawQuery('select * from quotes where id > ? limit 100', this.currentId);
       this.localList.addAll(elementsToAdd);
       this.currentId += 100;
   }

}

There could be two different places in the app that call add100elements at almost the same twice. That means the code will be executed twice, and add the same 100 elements.
I want to avoid this, by preventing the add100elements function to be called twice.
I could simply do this:

class DatabaseHelper {
   bool isRunning = false;

   Future<void> add100elements() async {
      // this functions queries a database and adds 100 elements from the db to a local list
      if (isRunning) return;
      isRunning = true;

      var elementsToAdd = await db.rawQuery('select * from quotes where id > ? limit 100', this.currentId);
      this.localList.addAll(elementsToAdd);
      this.currentId += 100;
      isRunning = false;
   }

}

But that feels a little manual and clumsy.

Is there a built-in way to do this in dart? Or a better way?

There have been several valid and useful suggestions in the comments. And I can add a couple things.

Pool

You could consider using the Pool class. This is useful when you want to limit the number of concurrent operations to some value N, but is perhaps overkill when N = 1 as in your use case.

Using Pool would differ from your flag-based approach in that an attempted concurrent run would run after the in-progress operation completes, rather than be skipped.

Flag

Your isRunner flag implementation is just fine, but can be made more robust using try/finally, as in:

   Future<void> add100elements() async {
      // this functions queries a database and adds 100 elements from the db to a local list
      if (isRunning) return;
      isRunning = true;
      
      try {
        var elementsToAdd = await db.rawQuery('select * from quotes where id > ? limit 100', this.currentId);
        this.localList.addAll(elementsToAdd);
        this.currentId += 100;
      }
      finally {
        isRunning = false;
      }
   }

This modification offers the advantage that the flag will be cleared even in the event of an exception. Otherwise, an exception would leave the flag permanently "stuck" in the true state.

You can go one step further if desired and abstract this if it's a common pattern:

import 'dart:async';

class OneAtATime {
  var _isRunning = false;
  
  Future<void> runOrSkip(FutureOr<void> Function() block) async {
    if (_isRunning) return;
    _isRunning = true;
    try {
      await block();
    }
    finally {
      _isRunning = false;
    }
  }
}

OneAtATime runner;

Future<void> add100elements() {
  return runner.runOrSkip(() async {
    var elementsToAdd = await db.rawQuery('select * from quotes where id > ? limit 100', this.currentId);
    this.localList.addAll(elementsToAdd);
    this.currentId += 100;
  });
}