Garbage Collection in Dart
Garbage Collection in Dart
About
- Garbage Collection automatically manages memory allocation/reclamation.
- Dart uses generational GC with young/old space.
- No stop-the-world pauses (incremental marking/concurrent sweeping).
- Each isolate has its own heap.
Main Topics
-
Generational Collection
- Definition: Young space (frequent collections) vs old space (less frequent).
- Example:
void createObjects() { // Allocated in young space var temp = List.filled(1000, 'data'); } // Collected quickly if unreachable
-
Mark-Sweep Algorithm
- Definition: Identifies and removes unreachable objects.
- Example:
var object1 = Object(); var object2 = Object(); object1 = null; // Now eligible for GC
-
Memory Allocation
- Definition: How Dart allocates objects.
- Example:
// Small objects in young space final point = Point(10, 20); // Large objects directly in old space final buffer = Uint8List(1000000);
-
GC Triggers
- Definition: Conditions that initiate collection.
- Example:
// Common triggers: // - Young space full // - Old space growth threshold // - Manual invocation (rarely needed)
-
Isolate Memory
- Definition: Independent heaps per isolate.
- Example:
// No shared memory between isolates // Communication via message passing
How to Use
- Best Practices: Avoid premature optimization
- Monitoring: Use DevTools Memory tab
- Large Data: Consider isolates for heavy processing
- Leak Detection: Watch for growing memory charts
How It Works
- Allocation: Objects created in young space
- Promotion: Surviving objects move to old space
- Marking: Traces object references
- Sweeping: Reclaims unreachable memory
- Compacting: (Occasionally) reduces fragmentation
Example Memory Profile:
void main() {
// Profile this in DevTools:
List<List<int>> matrix = [];
for (int i = 0; i < 1000; i++) {
matrix.add(List.filled(1000, i));
}
}
Conclusion
Dart’s garbage collector provides automatic memory management through efficient generational collection, enabling developers to focus on application logic rather than manual memory management. Its isolate-specific heaps and concurrent operations ensure smooth performance without blocking the main execution thread.