Что такое Dependency Injection (DI) в Flutter?

Ну вот, сидишь ты такой, пишешь на Dart, всё вроде красиво, async-await расставил, а приложение вдруг встаёт колом, как будто его в асфальт вкатали. Это, дружище, не баг, это классический DeadLock подъехал, или по-нашему — взаимная блокировка. Ситуация, когда две (или больше) асинхронных хуйни упёрлись рогами и ждут друг друга до второго пришествия. В Dart такое чаще из-за Future и изолятов вылазит, потому что тут один главный поток, а не толпа, как в других языках.

Типичная история, от которой волосы дыбом:

Представь, ты создал два Completer'а, как два упрямых барана.

Future<void> deadlockExample() async {
  final completer1 = Completer<void>();
  final completer2 = Completer<void>();

  Future<void> task1() async {
    print('Task1: ждём completer2');
    await completer2.future; // Сидим, смотрим на второго, ждём
    print('Task1: продолжаем');
    completer1.complete();
  }

  Future<void> task2() async {
    print('Task2: ждём completer1');
    await completer1.future; // А этот ждёт первого, ёпта!
    print('Task2: продолжаем');
    completer2.complete();
  }

  task1();
  task2();
  // И всё, приехали. Они оба повисли, как два хуя в проруби. Никто не завершится, потому что каждый ждёт другого. Идиотизм пиздец!
}

Вот это и есть deadlock в чистом виде. Каждый ждёт сигнала от другого, а сигнала-то и нет, потому что никто не дошёл до строчки complete(). Удивление пиздец, правда?

А вот реальная хрень из жизни — когда ты главный поток блокируешь:

// НЕПРАВИЛЬНО: делаешь вид, что асинхронно, а по факту вешаешь всё
void freezeUI() async {
  final data = await fetchData(); // Тут норм, ждём сеть

  // А тут начинается пиздец
  processDataSynchronously(data); // И тут ты, сука, на 5 секунд врубаешь синхронные вычисления!

  // Пока эта штука работает, твой UI — труп. Анимации встали, кнопки не жмутся. Пользователь думает, что приложение накрылось медным тазом.
}

Как надо делать, чтобы не быть распиздяем:

// ПРАВИЛЬНО: тяжёлое — в сторонку, в изолят
void properAsync() async {
  final data = await fetchData();

  // Говоришь: "Изолят, ёбни это за меня, а я пока покурю"
  final result = await Isolate.run(() {
    return processDataSynchronously(data); // Пусть парится в отдельной песочнице
  });

  // А UI в это время живой, отзывчивый, красивый. Все довольны.
  updateUI(result);
}

Так как же избежать этих ёбаных deadlock'ов?

1. С async/await не выёбывайся, делай всё последовательно.

   // Хорошо, понятно, предсказуемо
   Future<void> process() async {
     final a = await taskA();
     final b = await taskB(a); // Ждём A, потом делаем B
     return b;
   }
   
   // Плохо! Тут можно так запутаться, что сам от себя охуеешь.
   Future<void> riskyProcess() async {
     final futureA = taskA(); // Запустили
     final futureB = taskB(await futureA); // Чего бля? Смешали fire-and-forget с await.
     // Тут **подозрение ебать чувствую**, что где-то засядешь.
   }

2. Ставь таймауты, не верь никому.

   Future<void> safeOperation() async {
     try {
       await someFuture
         .timeout(const Duration(seconds: 5)); // Дай ему 5 секунд, и хватит.
     } on TimeoutException {
       // Не получилось? Ну и хуй с ним. Восстанавливайся, логируй.
       log('Operation timed out, иди нахуй');
     }
   }

3. С блокировками не умничай, вложенные — это прямой путь в ад.

   final lock = Lock();
   
   // ОПАСНО, НЕ ДЕЛАЙ ТАК
   Future<void> nestedLock() async {
     await lock.synchronized(() async {
       await lock.synchronized(() async { // Ты че, блядь? Ты уже внутри лока! Он тебя никогда не отпустит!
         // ...
       });
     });
   }
   // Это как пытаться выйти из комнаты, держась за ручку с той стороны. **Хуй с винтом** получится.

Чем искать эту заразу:

• flutter analyze — иногда подсветит тупняк.
• DevTools Performance — посмотри, где твой поток в говне тонет.
• Логи с таймстампами — чтобы понять, кто и когда встал.

В общем, чувак, в моих проектах deadlock обычно вылазит, когда начинается шаманство с общими ресурсами между изолятами или когда кто-то забывает, что event loop — он один, и начинает его взъёбывать синхронными операциями. Будь проще, используй изоляты для тяжёлого, ставь таймауты и не создавай циклических зависимостей между Future. Тогда и жить будет проще.