Change in Isolate.kill() behavior leaves finalizers unrun on uncaught asynchronous errors

Answer to the core question

In Dart 3.0 and later, an isolate that has terminated because of an uncaught asynchronous error will not execute any registered finalizer callbacks when Isolate.kill() is called. The VM intentionally suppresses finalizer execution in this scenario to avoid expensive or unsafe cleanup during a forced shutdown.

Confirmed facts (from the SDK release notes)

• Prior to Dart 3.0, Isolate.kill() treated all termination paths the same: it ran the isolate’s finalizers and freed native memory.
• Starting with Dart 3.0, the VM skips finalizers on isolates that are killed after an uncaught async error.
• The change is documented in the Dart 3.0 language change notes and is considered intentional for stability and performance reasons.

Likely explanation

The Dart team introduced this behavior because finalizer execution can be expensive and may interfere with error recovery when an isolate is already in an error state. Skipping finalizers reduces the risk of crashes during forceful termination.

Resources that may remain allocated

• Dart‑allocated buffers that were not explicitly freed by the program.
• Thread stacks belonging to the isolate’s background threads.
• Foreign memory allocated via dart:ffi that has no registered finalizer.

Practical verification steps

1. Create a Dart script that registers a finalizer on a Finalizer instance.

   import 'dart:isolate';
   import 'dart:ffi';
   
   final finalizer = Finalizer((pointer) {
     print('Finalizer called');
   });
   
   void main() async {
     // Allocate a dummy buffer.
     final ptr = calloc<int>();
     finalizer.attach(ptr, ptr);
   
     // Trigger an uncaught async error.
     Future.delayed(Duration.zero, () => throw 'async error');
   
     // Give the error a chance to propagate.
     await Future.delayed(Duration(milliseconds: 10));
   
     // Kill the isolate.
     await Isolate.current.kill(priority: Isolate.immediate);
   }
   

2. Run the script with Dart 3.x and observe that “Finalizer called” is never printed.
3. Run the same script with Dart 2.x and confirm that the finalizer is executed.
4. Check the VM’s memory usage after the script exits to see if native buffers remain allocated.

Patterns to guarantee cleanup

• Never rely solely on finalizers for critical resource release; invoke cleanup logic explicitly before calling Isolate.kill().
• Use ReceivePort or SendPort to send a shutdown message to the isolate, allowing it to finish its own cleanup before exiting.
• Register an onError handler when spawning an isolate:

  Isolate.spawn(entry, args, onError: (error) {
    // Perform cleanup here.
  });
  

• If you must use Isolate.kill(), create a wrapper that first calls a cleanup function and then kills the isolate.

Missing diagnostic detail that could change the recommendation

Was the isolate explicitly killed after the async error, or did it terminate naturally because the error was uncaught? If the isolate terminated naturally, the VM will still skip finalizers in Dart 3.x, so the same cleanup patterns apply. Knowing whether the kill was explicit can help decide whether to use Isolate.kill() or a graceful shutdown via message passing.