class FlutterSingleton {
  static FlutterSingleton? _instance;

  /// 將構(gòu)造方法聲明成私有的
  FlutterSingleton._();

  static FlutterSingleton getInstance() {
    if (_instance == null) {
      _instance = FlutterSingleton._();
    }
    return _instance!;
  }
}

class SPSingleton {
  static SPSingleton? _instance;

  String? data;

  /// 將構(gòu)造方法聲明成私有的
  SPSingleton._fromMap(Map map) : data = map['data'];

  static Future _fromSharedPreferences() async {
    // 模擬從 SharedPreferences 中讀取數(shù)據(jù), 并以此來(lái)初始化當(dāng)前對(duì)象
    Map map = {'data': 'mockData'};
    await Future.delayed(Duration(milliseconds: 10));
    return SPSingleton._fromMap(map);
  }

  static Future getInstance() async {
    if (_instance == null) {
      _instance = await SPSingleton._fromSharedPreferences();
    }
    return _instance!;
  }
}

void main() async {
  SPSingleton.getInstance().then((value) {
    print('instance1.hashcode = ${value.hashCode}');
  });
  SPSingleton.getInstance().then((value) {
    print('instance2.hashcode = ${value.hashCode}');
  });
}

static Future getInstance() async {
  if (_instance == null) { // 1
    _instance = await SPSingleton._fromSharedPreferences(); //2
  }
  return _instance!;
}

import 'dart:async';

class SPSingleton {
  static SPSingleton? _instance;
  static Completer? _monitor;

  String? data;

  /// 將構(gòu)造方法聲明成私有的
  SPSingleton._fromMap(Map map) : data = map['data'];

  static Future _fromSharedPreferences() async {
    // 模擬從 SharedPreferences 中讀取數(shù)據(jù), 并以此來(lái)初始化當(dāng)前對(duì)象
    Map map = {'data': 'mockData'};
    await Future.delayed(Duration(milliseconds: 10));
    return SPSingleton._fromMap(map);
  }

  static Future getInstance() async {
    if (_instance == null) {
      if (_monitor == null) {
        _monitor = Completer();
        _instance = await SPSingleton._fromSharedPreferences();
        _monitor!.complete(true);
      } else {
        // Flutter 的 Future 支持被多次 await
        await _monitor!.future;
        _monitor = null;
      }
    }
    return _instance!;
  }
}

void main() async {
  SPSingleton.getInstance().then((value) {
    print('instance1.hashcode = ${value.hashCode}');
  });
  SPSingleton.getInstance().then((value) {
    print('instance2.hashcode = ${value.hashCode}');
  });
}

static Future getInstance() async {
  if (_instance == null) { // 1
    if (_monitor == null) { // 2
      _monitor = Completer(); // 3
      _instance = await SPSingleton._fromSharedPreferences(); // 4
      _monitor!.complete(true); // 5
    } else {
      // Flutter 的 Future 支持被多次 await
      await _monitor!.future; //6
      _monitor = null;
    }
  }
  return _instance!; // 7
}

class Item {
  int id;
  String data;
  Item({
    required this.id,
    required this.data,
  });
}

class DBTest {
  DBTest._();
  static DBTest instance = DBTest._();
  bool _existsData = false;
  Future insert(String data) async {
    // 模擬數(shù)據(jù)庫(kù)插入操作,10毫秒過(guò)后,數(shù)據(jù)庫(kù)中才有數(shù)據(jù)
    await Future.delayed(Duration(milliseconds: 10));
    _existsData = true;
    print('執(zhí)行了插入');
  }

  Future update(String data) async {
    // 模擬數(shù)據(jù)庫(kù)更新操作
    await Future.delayed(Duration(milliseconds: 10));
    print('執(zhí)行了更新');
  }

  Future selected(int id) async {
    // 模擬數(shù)據(jù)庫(kù)查詢操作
    await Future.delayed(Duration(milliseconds: 10));
    if (_existsData) {
      // 數(shù)據(jù)庫(kù)中有數(shù)據(jù)才返回
      return Item(id: 1, data: 'mockData');
    } else {
      // 數(shù)據(jù)庫(kù)沒有數(shù)據(jù)時(shí),返回null
      return null;
    }
  }

  /// 先從數(shù)據(jù)庫(kù)表中查詢數(shù)據(jù)，查詢到了就更新，沒查詢到就插入
  Future insertOrUpdate(int id, String data) async {
    Item? item = await selected(id);
    if (item == null) {
      await insert(data);
    } else {
      await update(data);
    }
  }
}

void main() async {
  DBTest.instance.insertOrUpdate(1, 'data');
  DBTest.instance.insertOrUpdate(1, 'data');
}

import 'dart:async';
import 'dart:collection';

/// TaskQueue 不支持 submit await submit, 以下代碼就存在問(wèn)題
///
/// TaskQueue taskQueue = TaskQueue();
/// Future task1(String arg)async{
///   await Future.delayed(Duration(milliseconds: 100));
/// }
/// Future task2(String arg)async{
///   在這里submit時(shí), 任務(wù)會(huì)被添加到隊(duì)尾, 且當(dāng)前方法任務(wù)不會(huì)結(jié)束
///   添加到隊(duì)尾的任務(wù)必須等到當(dāng)前方法任務(wù)執(zhí)行完畢后, 才能繼續(xù)執(zhí)行
///   而隊(duì)尾的任務(wù)必須等當(dāng)前任務(wù)執(zhí)行完畢后, 才能執(zhí)行
///   這就導(dǎo)致相互等待, 使任務(wù)無(wú)法進(jìn)行下去
///   解決辦法是, 移除當(dāng)前的 await, 讓當(dāng)前任務(wù)結(jié)束
///   await taskQueue.submit(task1, arg);
/// }
///
/// taskQueue.submit(task2, arg);
///
/// 總結(jié):
/// 被 submit 的方法的內(nèi)部如果調(diào)用 submit 方法, 此方法不能 await, 否則任務(wù)隊(duì)列會(huì)被阻塞住
///
/// 如何避免此操作, 可以借鑒以下思想:
/// 以數(shù)據(jù)庫(kù)操作舉例, 有個(gè)save方法的邏輯是插入或者更新(先查詢數(shù)據(jù)庫(kù)select,再進(jìn)行下一步操作);
/// sava方法內(nèi)部submit,并且select也submit, 就容易出現(xiàn)submit await submit的情況
///
/// 我們可以這樣操作,假設(shè)當(dāng)前類為 DBHelper:
/// 將數(shù)據(jù)庫(kù)的增,刪,查,改操作封裝成私有的 async 方法, 且私有方法不能使用submit
/// DBHelper的公有方法, 可以調(diào)用自己的私有 async 方法, 但不能調(diào)用自己的公有方法, 公有方法可以使用submit
/// 這樣就不會(huì)存在submit await submit的情況了
class TaskQueue {
  /// 提交任務(wù)
  Future submit(Function fun, A? arg) async {
    if (!_isEnable) {
      throw Exception('current TaskQueue is recycled.');
    }
    Completer result = new Completer();

    if (!_isStartLoop) {
      _isStartLoop = true;
      _startLoop();
    }

    _queue.addLast(_Runnable(
      fun: fun,
      arg: arg,
      completer: result,
    ));
    if (!(_emptyMonitor?.isCompleted ?? true)) {
      _emptyMonitor?.complete();
    }

    return result.future;
  }

  /// 回收 TaskQueue
  void recycle() {
    _isEnable = false;
    if (!(_emptyMonitor?.isCompleted ?? true)) {
      _emptyMonitor?.complete();
    }
    _queue.clear();
  }

  Queue<_Runnable> _queue = Queue<_Runnable>();
  Completer? _emptyMonitor;
  bool _isStartLoop = false;
  bool _isEnable = true;

  Future _startLoop() async {
    while (_isEnable) {
      if (_queue.isEmpty) {
        _emptyMonitor = new Completer();
        await _emptyMonitor!.future;
        _emptyMonitor = null;
      }

      if (!_isEnable) {
        // 當(dāng)前TaskQueue不可用時(shí), 跳出循環(huán)
        return;
      }

      _Runnable runnable = _queue.removeFirst();
      try {
        dynamic result = await runnable.fun(runnable.arg);
        runnable.completer.complete(result);
      } catch (e) {
        runnable.completer.completeError(e);
      }
    }
  }
}

class _Runnable {
  final Completer completer;
  final Function fun;
  final A? arg;

  _Runnable({
    required this.completer,
    required this.fun,
    this.arg,
  });
}

void main() async {
  Future test1(String data) async {
    await Future.delayed(Duration(milliseconds: 20));
    print('執(zhí)行了test1');
  }

  Future test2(Map args) async {
    await Future.delayed(Duration(milliseconds: 10));
    print('執(zhí)行了test2');
    return 'mockResult';
  }

  TaskQueue taskQueue = TaskQueue();
  taskQueue.submit(test1, '1');
  taskQueue.submit(test2, {
    'data1': 1,
    'data2': '2',
  }).then((value) {
    print('test2返回結(jié)果:${value}');
  });

  await Future.delayed(Duration(milliseconds: 200));
  taskQueue.recycle();
}
/*
執(zhí)行輸出結(jié)果如下:

執(zhí)行了test1
執(zhí)行了test2
test2返回結(jié)果:mockResult
*/

class Item {
  int id;
  String data;
  Item({
    required this.id,
    required this.data,
  });
}

class DBTest {
  DBTest._();
  static DBTest instance = DBTest._();
  TaskQueue _taskQueue = TaskQueue();
  bool _existsData = false;
  Future _insert(String data) async {
    // 模擬數(shù)據(jù)庫(kù)插入操作,10毫秒過(guò)后,數(shù)據(jù)庫(kù)才有數(shù)據(jù)
    await Future.delayed(Duration(milliseconds: 10));
    _existsData = true;
    print('執(zhí)行了插入');
  }

  Future insert(String data) async {
    await _taskQueue.submit(_insert, data);
  }

  Future _update(String data) async {
    // 模擬數(shù)據(jù)庫(kù)更新操作
    await Future.delayed(Duration(milliseconds: 10));
    print('執(zhí)行了更新');
  }

  Future update(String data) async {
    await _taskQueue.submit(_update, data);
  }

  Future _selected(int id) async {
    // 模擬數(shù)據(jù)庫(kù)查詢操作
    await Future.delayed(Duration(milliseconds: 10));
    if (_existsData) {
      // 數(shù)據(jù)庫(kù)中有數(shù)據(jù)才返回
      return Item(id: 1, data: 'mockData');
    } else {
      // 數(shù)據(jù)庫(kù)沒有數(shù)據(jù)時(shí),返回null
      return null;
    }
  }

  Future selected(int id) async {
    return await _taskQueue.submit(_selected, id);
  }

  /// 先從數(shù)據(jù)庫(kù)表中查詢數(shù)據(jù)，查詢到了就更新，沒查詢到就插入
  Future _insertOrUpdate(Map args) async {
    int id = args['id'];
    String data = args['data'];
    Item? item = await _selected(id);
    if (item == null) {
      await _insert(data);
    } else {
      await _update(data);
    }
  }

  Future insertOrUpdate(int id, String data) async {
    return await _taskQueue.submit(_insertOrUpdate, {
      'id': id,
      'data': data,
    });
  }
}

void main() async {
  DBTest.instance.insertOrUpdate(1, 'data');
  DBTest.instance.insertOrUpdate(1, 'data');
}