Почему Dart однопоточный?

Почему Dart однопоточный?

Eto часто спрашивают на собеседованиях, потому что многие путают однопоточность с неспособностью выполнять асинхронные операции. Разберу подробно, почему архитектура Dart именно такая и в чём её преимущества.

Что значит "однопоточный"?

Дарт не является полностью многопоточным в классическом понимании. У каждого Dart процесса есть один основной поток выполнения (event loop), хотя существуют Isolates — отдельные потоки исполнения.

// Dart однопоточный на уровне event loop
main() {
  // Весь код здесь выполняется в одном потоке
  print('Start');       // Выполняется сразу
  
  Future.delayed(Duration(seconds: 1), () {
    print('After 1 second');  // Выполняется после 1 сек
  });
  
  print('End');         # Выполняется сразу (до Future!)
}

// Вывод:
// Start
// End
// After 1 second

История: Почему сделали так?

Проблемы многопоточности

// ❌ ПЛОХО: Классическая многопоточность (Java, C++)
int counter = 0;

void increment() {
  counter++;  // Без синхронизации это неопасно!
}

void main() {
  // Создаём 2 потока
  Thread thread1 = new Thread(() => increment());
  Thread thread2 = new Thread(() => increment());
  
  thread1.start();
  thread2.start();
  
  thread1.join();
  thread2.join();
  
  print(counter);  // Может быть 1 или 2!
  // Race condition!
}

Проблемы многопоточности:

• Race conditions (состояние гонки)
• Deadlock'и (взаимные блокировки)
• Сложность отладки
• Очень трудно учить начинающих разработчиков

Решение Dart: Event Loop + Async/Await

Дарт выбрал другой путь, вдохновлённый JavaScript и Node.js.

// ✅ ХОРОШО: Однопоточный event loop
int counter = 0;

void increment() async {
  counter++;  // Всегда безопасно!
}

void main() async {
  await increment();  // Выполняется последовательно
  await increment();
  
  print(counter);  // Всегда 2
}

Как работает Event Loop в Dart?

// Event Loop имеет 2 очереди

// 1. Microtask queue (микротаски)
// Высший приоритет: Future.microtask(), Schedulers
Scheduler.microtask(() => print('Microtask'));

// 2. Event queue (события)
// Обычные операции: Future, Timer, I/O
Timer(Duration(seconds: 1), () => print('Timer'));

// Event Loop цикл:
// 1. Выполни всю синхронный код
// 2. Выполни все microtask'и
// 3. Выполни одно событие из event queue
// 4. Повтори

void main() {
  print('1. Sync start');  # Синхронно, сразу
  
  Future.microtask(() => print('2. Microtask'));  # После синхро, до event queue
  
  Future.delayed(Duration.zero, () => print('3. Event queue'));  # После microtask
  
  Timer(Duration(seconds: 1), () => print('4. Timer 1s'));  # После event queue
  
  print('5. Sync end');  # Синхронно, сразу
}

// Вывод:
// 1. Sync start
// 5. Sync end
// 2. Microtask
// 3. Event queue
// 4. Timer 1s

Преимущества однопоточного Dart

1. Безопасность доступа к данным

// ✅ БЕЗОПАСНО: Dart гарантирует
class User {
  String _name = '';
  
  String getName() => _name;
  void setName(String value) => _name = value;
}

// Нет race condition'ов!
final user = User();

// Все эти операции безопасны
user.setName('John');
print(user.getName());  // Всегда 'John'

// Даже с async
future1.then((_) => user.setName('Alice'));
future2.then((_) => print(user.getName()));
// Может быть '' или 'Alice', но не undefined state

2. Простота разработки

// ✅ Не нужны мьютексы, семафоры, volatile
// Нет synchronized() ключевого слова

class Counter {
  int _value = 0;
  
  // Просто метод, без синхронизации!
  void increment() => _value++;
  int getValue() => _value;
}

// Всегда работает корректно
final counter = Counter();
counter.increment();  // Безопасно
print(counter.getValue());  // Предсказуемо

3. Простота отладки

// ✅ Отладка проще
final user = User();

future1.then((_) {
  user.name = 'Alice';
  print('Set Alice');  # Когда вызовется?
});

future2.then((_) {
  print('Name is: ${user.name}');  # Всегда 'Alice'
});

// Выполнение последовательно в одном потоке
// Легко отследить в отладчике

4. Предсказуемое поведение

// ✅ Результат всегда предсказуем
List<int> numbers = [];

future1.then((_) => numbers.add(1));
future2.then((_) => numbers.add(2));
future3.then((_) => numbers.add(3));

// После всех futures: numbers = [1, 2, 3]
// Всегда в порядке выполнения future'ов

// В многопоточности это было бы [1,2,3], [1,3,2], [2,1,3] и т.д.

Как работать с асинхронностью в Dart?

1. Futures для асинхронных операций

// ✅ Асинхронность работает отлично
Future<String> fetchData() async {
  // I/O операция — не блокирует event loop
  final response = await http.get(Uri.parse('https://api.example.com/data'));
  return response.body;
}

void main() async {
  print('Fetching...');
  
  // await ждёт, но не блокирует
  // Другие события могут выполняться
  final data = await fetchData();
  
  print('Data: $data');
}

2. Streams для непрерывных данных

// ✅ Streams — асинхронные итерации
Stream<int> countdownStream() async* {
  for (int i = 5; i >= 0; i--) {
    yield i;
    await Future.delayed(Duration(seconds: 1));
  }
}

void main() async {
  await for (final count in countdownStream()) {
    print('$count...');
  }
}

// Вывод:
// 5...
// 4...
// 3...
// 2...
// 1...
// 0...

3. Isolates для многопоточности (когда нужна)

// ✅ Если ДЕЙСТВИТЕЛЬНО нужна многопоточность
future_result(int value) => value * 2;

void main() async {
  // Isolate — отдельный поток
  final result = await Isolate.run(() => future_result(21));
  print('Result: $result');  # 42
}

// Isolate'ы:
// + Полностью изолированы (нет race conditions)
// + Могут выполняться параллельно
// - Сложнее в использовании
// - Медленнее (overhead на создание)

Сравнение: Dart vs Java (многопоточность)

// JAVA: Многопоточность
// synchronized (очень сложно)
public class Counter {
  private int value = 0;
  
  public synchronized void increment() {
    value++;  // Даже это требует synchronization!
  }
  
  public synchronized int getValue() {
    return value;
  }
}

final counter = new Counter();
new Thread(() -> counter.increment()).start();
new Thread(() -> counter.increment()).start();
// Может быть value=1 или value=2! Race condition!

// DART: Однопоточность
// Никакой синхронизации
class Counter {
  int _value = 0;
  
  void increment() => _value++;
  int getValue() => _value;
}

final counter = Counter();
counter.increment();
counter.increment();
print(counter.getValue());  // Всегда 2

Когда однопоточность Dart может быть проблемой?

1. CPU-intensive операции

// ❌ ПЛОХО: Долгая операция блокирует event loop
int heavyCalculation(int n) {
  int sum = 0;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < i; j++) {
      sum += i * j;  # Очень долгая операция
    }
  }
  return sum;
}

void main() {
  // Этот вызов БЛОКИРУЕТ весь UI!
  final result = heavyCalculation(10000);
  
  // Экран зависает, не обновляется, не реагирует на тапы
  print('Result: $result');
}

// ✅ ХОРОШО: Используй Isolate
future<int> heavyCalculationIsolate(int n) {
  return Isolate.run(() => heavyCalculation(n));
}

void main() async {
  // Вычисление в отдельном потоке
  // UI остаётся отзывчивым
  final result = await heavyCalculationIsolate(10000);
  print('Result: $result');
}

2. Много синхронных операций

// ❌ Если много синхрона — может быть проблема
for (int i = 0; i < 1000000; i++) {
  processData(i);  # Если каждый занимает 1мс = 1000 сек!
}

// ✅ Решение: разбить на части
for (int i = 0; i < 1000000; i += 1000) {
  await Future.delayed(Duration.zero);
  for (int j = i; j < i + 1000; j++) {
    processData(j);
  }
}

Best Practice: Избегание UI фриза

// ❌ ПЛОХО: Фризит UI
class DataLoader {
  void loadAndProcess() {
    final data = loadLargeFile();  # Долго!
    final processed = process(data);  # Ещё дольше!
    updateUI(processed);  # UI зависает
  }
}

// ✅ ХОРОШО: Асинхронно
class DataLoader {
  Future<void> loadAndProcess() async {
    final data = await loadLargeFileAsync();  # Не блокирует
    final processed = await computeAsync(data);  # В background
    updateUI(processed);  # UI отзывчив
  }
}

// ✅ ЕЩЁ ЛУЧШЕ: Для CPU-intensive
class DataLoader {
  Future<void> loadAndProcess() async {
    final data = await loadLargeFileAsync();
    final processed = await compute(process, data);  # Isolate
    updateUI(processed);
  }
}

Event Loop визуально

┌─────────────────────────────────────────┐
│         Dart Event Loop                 │
├─────────────────────────────────────────┤
│                                         │
│  1. Выполни весь синхронный код       │
│  2. Выполни все microtask'и             │
│  3. Выполни одно событие из event queue│
│  4. Повтори, если есть ещё события     │
│                                         │
└─────────────────────────────────────────┘

Пример:

code          Sync code (немедленно)
│             ├─ print('1')
│             └─ print('5')
│
├─ Microtask  Queue (высокий приоритет)
│             └─ print('2')
│
└─ Event queue (нормальный приоритет)
              ├─ print('3')
              └─ print('4')

Резюме

Почему Dart однопоточный?

1. Безопасность — нет race conditions
2. Простота — не нужны мьютексы и synchronized
3. Предсказуемость — результаты всегда одинаковые
4. Простота разработки — проще учиться
5. Простота отладки — легче отследить выполнение

Как это работает?

• Event Loop с двумя очередями (microtask + event)
• Futures/async-await для асинхронности
• Isolates для многопоточности (если нужна)

Ограничения?

• ❌ CPU-intensive операции блокируют UI
• ❌ Много синхронного кода может фризить интерфейс

Решение:

• ✅ Используй async/await
• ✅ Используй Isolate.run() для тяжёлых операций
• ✅ Разбивай большие операции на части с await Future.delayed()