Что такое livelock (живая блокировка) в асинхронном программировании?

А, ну это же классика, ебать мои старые костыли! Смотри, есть такая хуйня — livelock, или «живая блокировка». Представь себе двух вежливых мудаков в дверном проёме. Один говорит: «проходи ты», другой — «нет, ты первый». И так они там топчутся, уступают друг другу, оба вроде не зависли, но нихуя не двигаются с места. Это и есть livelock. Не deadlock, где всё встало колом, а вот эта вот мартышлюшка с бесконечным «после вас».

В коде это выглядит так: две асинхронные таски (или изоляты в Dart) нихуя не блокируют друг друга намертво, а просто как два идиота постоянно меняют своё состояние в ответ на действия соседа, и полезной работы — ноль. Полный пиздец, одним словом.

Вот, смотри на этот гипотетический пример. Два будуна (taskA и taskB) хотят писать в общий лог, но по одному. У них общий флаг canWrite.

import 'dart:async';

// Общий ресурс — флаг, кто может писать в лог
bool canWrite = true;

Future<void> taskA() async {
  while (true) {
    if (canWrite) {
      canWrite = false; // Захватываем право на запись
      print('Task A is writing...');
      await Future.delayed(Duration(milliseconds: 10));
      canWrite = true; // Освобождаем
      break; // Выходим после успешной работы
    } else {
      // Вежливо уступаем и ждем
      print('Task A: waiting...');
      await Future.delayed(Duration(milliseconds: 1));
      // Проблема: к этому моменту taskB тоже мог уступить,
      // и оба снова попытаются захватить ресурс одновременно.
    }
  }
}

Future<void> taskB() async {
  while (true) {
    if (canWrite) {
      canWrite = false;
      print('Task B is writing...');
      await Future.delayed(Duration(milliseconds: 10));
      canWrite = true;
      break;
    } else {
      print('Task B: waiting...');
      await Future.delayed(Duration(milliseconds: 1));
    }
  }
}

void main() async {
  // Запускаем обе задачи "одновременно"
  await Future.wait([taskA(), taskB()]);
  print('Done'); // Эта строка может никогда не выполниться при неудачном тайминге.
}

Видишь подвох? Оба видят, что флаг true, оба пытаются его захватить. Но из-за асинхронности и мелких задержек они могут попасть в пиздопроебибну: один захватил, другой увидел false, вежливо подождал миллисекунду, отпустил флаг... а первый к этому моменту тоже уже подождал и отпустил! И они снова стартуют с одного места. И так до скончания времён, print('Done') ты можешь и не увидеть. Удивление пиздец, да? Сам от себя охуеешь, когда такое в логах найдёшь.

Как не наступить на эти грабли в Flutter/Dart:

1. Хватит выёбываться с ручными флагами. Это же ёперный театр! Бери нормальные примитивы синхронизации. Тот же Future, но с очередью, или Completer. Есть куча пакетов вроде async, где тебе и семафоры (Pool), и мьютексы подсунут. Не изобретай велосипед, чувак.
2. Ломай симметрию. Если уж попал в ситуацию «вежливого ожидания», добавь хоть немного хаоса. Сделай задержки разными или, на хуй, случайными. Пусть один ждёт 1 мс, а другой 3. Шанс, что они опять синхронно дерганутся, резко падает.
3. Перепроектируй архитектуру, блядь. Может, не надо двум задачам драться за один ресурс, как последним пидарасам? Используй отдельные StreamController для каждого, или в том же Flutter'е Provider с атомарными обновлениями состояния. Сделай так, чтобы им не было за что бороться.
4. Ставь таймауты, ебанашка. Бесконечное вежливое ожидание — это пиздец. Скажи задаче: «чувак, если за 5 секунд не получилось — отъебись и доложи об ошибке». И жить станет проще.

В реальном Flutter'е такие явные livelock'и, конечно, редкость. Но если понимаешь эту механику, то сразу видишь, где твой асинхронный код может начать бздеть на месте, и не допускаешь таких косяков с обновлением стейта или работой изолятов. Э бошка думай!