adfadf

                    PK_OBJ: v.bg(v.onCompleteObj).start;
                  end;
                end;

                TK_UI: begin
                  case v.onCompletePKind of
                    PK_GLB: v.ui(v.onCompleteGlb).start; //新衍生的协程，不携带数据和作用域，查找的话也是查找父节点的数据和依赖父节点作用域；

                    PK_OBJ: v.ui(v.onCompleteObj).start;
                  end;
                end;
              end;
            end else begin
              //没有回调就修改状态为 completed，等待下次循环回收
              AtomicExchange(v.state, ST_COMPLETED);
            end;
          end;
          v.childsLock.Leave;
        end;
      end;

      ST_CANCELING: begin
        //看下是否有分支
        if v.childsLock.TryEnter then //没进来就先跳过，等待下次循环
        begin
          //还存在分支就跳过什么都不做，让其分支继续完成
          if (v.childs = nil) or (v.childs.IsEmpty) then
          begin
            //不存在分支的话，就看下是否有成功回调
            if v.isExistOnCancel then
            begin
              //有回调，就衍生回调
              AtomicExchange(v.state, ST_ON_CANCELING);
              case v.onCancelTKind of
                TK_BG: begin
                  case v.onCancelPKind of
                    PK_GLB: v.bg(v.onCancelGlb).start; //新衍生的协程，不携带数据和作用域，查找的话也是查找父节点的数据和依赖父节点作用域；

                    PK_OBJ: v.bg(v.onCancelObj).start;
                  end;
                end;

                TK_UI: begin
                  case v.onCancelPKind of
                    PK_GLB: v.ui(v.onCancelGlb).start; //新衍生的协程，不携带数据和作用域，查找的话也是查找父节点的数据和依赖父节点作用域；

                    PK_OBJ: v.ui(v.onCancelObj).start;
                  end;
                end;
              end;
            end else begin
              //没有回调就修改状态为 终态，等待下次循环回收
              AtomicExchange(v.state, ST_CANCELED);
            end;
          end;
          v.childsLock.Leave;
        end;
      end;

      ST_ON_COMPLETING: begin
        //看下是否还有分支，有分支就说明回调子任务还没有执行完就跳过，无分支就修改为终态，让GC下次循环回收
        if v.childsLock.TryEnter then
        begin
          if (v.childs = nil) or (v.childs.IsEmpty) then
          begin
            AtomicExchange(v.state, ST_COMPLETED);
          end;
          v.childsLock.Leave;
        end;
      end;

      ST_ON_CANCELING: begin
        //看下是否还有分支，有分支就说明回调子任务还没有执行完就跳过，无分支就修改为终态，让GC下次循环回收
        if v.childsLock.TryEnter then
        begin
          if (v.childs = nil) or (v.childs.IsEmpty) then
          begin
            AtomicExchange(v.state, ST_CANCELED);
          end;
          v.childsLock.Leave;
        end;
      end;


      ST_COMPLETED, ST_CANCELED: begin //终态的话加入free队列
        freeIds.Add(v.id);
      end;
    end;
  end;


  //开始删除
  if not freeIds.IsEmpty then
  begin
    for var v in freeIds do
    begin
      var tsk := map.Items[v];

      //无论是普通的协程还是重复的协程，完全关系解除成功后，这里都是先删除
      map.Remove(v);

      //判断是否是重复协程，重复的协程不需要解除关系
      if not tsk.isRpt then
      begin
        var isAllSuccess := True; //全部关系解除成功
        //1. 解除 与 TTaskForm 的关系映射
        if (tsk.FScopes <> nil) and (not tsk.FScopes.IsEmpty) then
        begin
          for var f in tsk.FScopes do
          begin
            if f.tasksLock.TryEnter then //提升gc的效率，不等待，不行就跳过下次再说
            begin
              if (f.tasks = nil) or (not f.tasks.ContainsKey(v)) then
              begin
                ShowCoreErrorMsg('协程核心错误，ID在scopes中找不到！');
              end;

              f.tasks.Remove(v);
              if (f.tasks.IsEmpty) and (f.isFreeIng) then
              begin
                needGcForm := True;
              end;
              f.tasksLock.Leave;
            end else begin
              isAllSuccess := False; //未能解除成功，等待下次循环再尝试
            end;
          end;
        end;

        //2.解除与父节点的关系; root 是不会在全局容器中的，不用考虑 root的父节点的问题
        var parentTsk := tsk.parent;
        if parentTsk.childsLock.TryEnter then
        begin
          parentTsk.childs.Remove(tsk.id);
          parentTsk.childsLock.Leave;
        end else begin
          isAllSuccess := False; //未能解除成功，等待下次循环再尝试
        end;

        //3.最后若以上都成功了，则释放
        if isAllSuccess then
        begin
          tsk.Free; //先释放
          map.Remove(v); //从 done 容器移除
        end;
      end else begin
        {
          说明是重复的协程的步骤，切记：先从done容器中移除，然后再加入 rpt 容器，
          避免先 rpt容器，rpt若是正好醒来，这个协程又会快速执行，又进入done容器，
          导致 key 键重复；重复的协程不释放；
        }
        //1. 先从done容器中移除
        map.Remove(v);

        //2.重新计算下次运行时间
        tsk.nextTime := currentTimeMillis + tsk.rptInterval;

        //3.改变 state 为new
        AtomicExchange(tsk.state, ST_NEW);

        //4.再次加入容器，所有地方统一在 df 线程排序；
        glRptListLock.Enter; //这里不能使用 tryEnter了，这里无法跳过，必须等待
        glRptList.Add(tsk);
        glRptListLock.Leave;

        //5.通知延迟线程醒来看下
        rptThread.event.SetEvent;
      end;
    end;
  end;

  freeIds.Free; //释放
end;
mapLock.Leave; //释放锁

end;
end;

///

//1. main 完毕容器
gcTask(mainDoneMap, mainDoneMapLock, needGcForm);

//2. rpt 完毕容器
gcTask(rptDoneMap, rptDoneMapLock, needGcForm);

//3. wk 完毕容器
for var th in wkThreads do
begin
 gcTask(th.lcDoneMap, th.lcDoneMapLock, needGcForm);
end;


//本轮完毕后，若最后发现需要主线程回收窗体，则向主线程投递遍历回收窗体的方法
if needGcForm then
begin
  log('gc - main 发送 gcForm');
  TThread.Queue(nil, self.letMainGcTaskForm);
end;


//最后都做完了后，睡眠一会自我醒来
Sleep(SLEEP_GC_MS);
//醒来后就递减次数，只有gc访问这个，不存在多线程的问题
if GC_MAIN_CYCLE = 0 then
begin
  //补偿发送
  TThread.Queue(nil, self.letMainGcTaskForm);
  log('gc - main 补偿发送');
  GC_MAIN_CYCLE := 100;
end else begin
  Dec(GC_MAIN_CYCLE);
end;

end;
//关闭程序的时候才会走到这里，否则不会走到这里
log('线程终止');
end;

///

constructor TTask.Create;
begin
inherited Create;
id := TGUID.NewGuid.ToString;
childsLock := TCriticalSection.Create; //锁必须初始化
isRpt := False; //默认不是重复协程
state := ST_NEW; //新创建的协程默认是NEW状态
wkThreadIndex := - 1; //故意默认为 -1 ，这样有逻辑问题时，方便报错
end;

destructor TTask.Destroy;
begin
childsLock.Free;
//分支也是动态创建的
if childs <> nil then
begin
childs.Free;
end;
//FData是动态创建的，所以判断下
if FData <> nil then
begin
FData.Free;
end;
//作用域是动态创建的，所以判断下
if FScopes <> nil then
begin
//协程 与 XForm的关系为：协程不在了，XForm可能还在；协程在XForm一定存在，所以释放协程时，只需释放字段就行，不要释放formx
//gc那里已经处理了，作用域formx的问题，这里只是简单的释放就可
FScopes.Free;
end;
log(Self.id + ' ----- 被释放了');
inherited;
end;

procedure TTask.setGlobalExceptionHandler(handler: TExceptionHandler);
begin
if not Assigned(CONFIG_EXCEPTION_HANDLER) then
begin
CONFIG_EXCEPTION_HANDLER := handler;
end else ShowCoreErrorMsg('开发人员错误，全局异常函数，只可配置一次！');
end;

procedure TTask.outNoArgProc;
begin
{
首先要明确，在等待执行的队列 bg/uiQueue中 只可能存在 2种状态，即：NEW, CANCELING，
因为能在这个队列中存在，说明还没有开始执行。
1.当前协程在队列中处于NEW状态，此时可演变成DOING
2.当前协程在队列中处于CANCELING状态，就是说由异常、作用域关闭、主动取消父节点，
而引起的取消中，这类的直接跳过，其它的情况不存在，就报错。
}
case Self.state of
ST_NEW: begin
//只有NEW可以演变成DOING，取消的线程发现是doing了，就会结束向下递归，而是把取消的权利转让给当前线程
AtomicExchange(Self.state, ST_DOING);

  {
    留意点在执行时要锁住childs，这样一旦被外部修改成canceling，子节点又被其它线程完成了，gc开始回收子节点，
    去父节点的 childs那里 删除指针，不能让其删除，由于 gc.childsLock.tryEnter 拿不到锁就会走开，这样让自己执
    行完毕后再判断状态，进入如果架构图所示流程，避免父节点生成着，GC 回收着子节点，可能会出现意外的问题，要求
    必须父节点完成了，gc才有可能回收子节点；
  }
  Self.childsLock.Enter;

  //接下来开始执行代码
  try
    case Self.pkind of
      PK_GLB: Self.procGlb(Self);
      PK_OBJ: Self.procObj(Self);
    end;

    {
     此时说明没有发生异常，走到这里state的情况为：
     1. doing
     2. canceling 被上层修改为了取消中
     只有以上2种可能否则就是逻辑有问题
    }
    case Self.state of
      ST_DOING: AtomicExchange(Self.state, ST_COMPLETING);

      ST_CANCELING: begin
        //若有分支就 接力棒式 递归向下取消
        if (Self.childs <> nil) and (not Self.childs.IsEmpty) then
        begin
          for var c in Self.childs.Values do
          begin
            cancelTask(c);
          end;
        end;
      end;

      else ShowCoreErrorMsg('核心错误，状态只可能是 doing 或 canceling，请联系开发者！');
    end;

    Self.childsLock.Leave; //执行完毕后才松开子节点锁
  except
    //这里若有代码则编译不通过，必须放到 on 内部
    on e: Exception do
    begin
      //有异常的时候，标记为canceling，会被GC最终执行全局异常函数，异常并不会影响协程的继续
      AtomicExchange(Self.state, ST_CANCELING);
      //若有分支就 接力棒式 递归向下取消
      if (Self.childs <> nil) and (not Self.childs.IsEmpty) then
      begin
        for var c in Self.childs.Values do
        begin
          cancelTask(c);
        end;
      end;
      Self.childsLock.Leave; //在这里松开子节点的锁

      //判断是否分配了全局异常处理函数
      if Assigned(CONFIG_EXCEPTION_HANDLER) then
      begin
        //这里就是主线程了，所以直接执行 没有必要 TThread.Synchronize
        CONFIG_EXCEPTION_HANDLER(e);
      end else begin
        //没有分配的时候，默认在主线程里弹出官方的默认窗体报错，Application.ShowException 只
        //能在主线程里运行，无论是普通的窗体还是Dialog，因为有窗体消息循环都只能在主线程里运行；
        Application.ShowException(e);
      end;
    end;
  end;

  //进入完毕队列
  mainDoneMapLock.Enter;
  mainDoneMap.Add(Self.id, Self);
  mainDoneMapLock.Leave;
end;

ST_CANCELING: begin
  //转入完毕队列
  mainDoneMapLock.Enter;
  mainDoneMap.Add(Self.id, Self);
  mainDoneMapLock.Leave;
end;

else ShowCoreErrorMsg('核心错误，状态只可能是 new 或 canceling，请联系开发者！');

end;
end;

function TTask.isCancel: Boolean;
begin
{
当程序退出时，BG/UI线程若在执行耗时较久的协程，那么在协程内部应该判断isCancel，
来最快的响应退出，程序员不需要关注 APP_EXIT这个变量，仅仅通过一个isCancel来决
定是否退出协程
}
if not TASK_IS_RUNING then
begin
Exit(True);
end;

case Self.state of
ST_CANCELING, ST_ON_CANCELING, ST_CANCELED: Exit(True);
else Exit(False);
end;
end;

function TTask.getString(key: string): string;
begin
Result := findValue(Self, key).AsString;
end;

function TTask.getInteger(key: string): Integer;
begin
Result := findValue(Self, key).AsInteger;
end;

function TTask.getBoolean(key: string): Boolean;
begin
Result := findValue(Self, key).AsBoolean;
end;

function TTask.getInt64(key: string): Int64;
begin
Result := findValue(Self, key).AsInt64;
end;

function TTask.getUInt64(key: string): UInt64;
begin
Result := findValue(Self, key).AsUInt64;
end;

function TTask.getCurrency(key: string): Currency;
begin
Result := findValue(Self, key).AsCurrency;
end;

function TTask.getExtended(key: string): Extended;
begin
Result := findValue(Self, key).AsExtended;
end;

function TTask.bg(proc: TProcGlb): TTask;
begin
if forkTemp <> nil then
begin
ShowCoreErrorMsg('开发人员书写错误，不可以重复使用bg');
end;

forkTemp := TTask.Create;
forkTemp.tkind := TK_BG;
forkTemp.pkind := PK_GLB;
forkTemp.procGlb := proc;

Result := Self;
end;

function TTask.bg(proc: TProcObj): TTask;
begin
if forkTemp <> nil then
begin
ShowCoreErrorMsg('开发人员书写错误，不可以重复使用bg');
end;

forkTemp := TTask.Create;
forkTemp.tkind := TK_BG;
forkTemp.pkind := PK_OBJ;
forkTemp.procObj := proc;

Result := Self;
end;

function TTask.ui(proc: TProcGlb): TTask;
begin
if forkTemp <> nil then
begin
ShowCoreErrorMsg('开发人员书写错误，不可以重复使用ui');
end;

forkTemp := TTask.Create;
forkTemp.tkind := TK_UI;
forkTemp.pkind := PK_GLB;
forkTemp.procGlb := proc;

Result := Self;
end;

function TTask.ui(proc: TProcObj): TTask;
begin
if forkTemp <> nil then
begin
ShowCoreErrorMsg('开发人员书写错误，不可以重复使用ui');
end;

forkTemp := TTask.Create;
forkTemp.tkind := TK_UI;
forkTemp.pkind := PK_OBJ;
forkTemp.procObj := proc;

Result := Self;
end;

function TTask.data(data: TArray): TTask;
var
key: string;
len, i: Integer;
begin
if forkTemp = nil then
begin
ShowCoreErrorMsg('开发人员书写错误，应该先调用bg/ui才能继续！');
end;

//禁止task.data().data().data()这种写法一次性写入提高效率task.data(多行写入更加直观，效率也高)
if forkTemp.FData <> nil then
begin
ShowCoreErrorMsg('开发人员书写错误，禁止data().data()这种不直观语法，请核查！');
end;

len := Length(data);
if len = 0 then
begin
//这里不报错，直接退出，有时候为了方便调式会注释掉data里的参数
Exit(Self);
end;

//判断能否被2整除
if (len mod 2) <> 0 then
begin
ShowCoreErrorMsg('开发人员书写错误，数据参数必须成对输入，请核查！');
end;

//开始创建容器，循环一次性写入，当不使用data的时候，容器是为nil的，提升效率
forkTemp.FData := TDictionary<string, TValue>.Create;
for i := 0 to (len - 1) do
begin
if (i mod 2) = 0 then
begin
key := data[i].AsString;
end
else
begin
//判断value是否是支持的类型
case data[i].Kind of
//string会自动匹配这个
tkUString, tkInteger,
//Boolean会是这个
tkEnumeration,
//经过测试Int64和UInt64都会匹配到这个，可以参考我博客上的文章，结果是正常的
tkInt64,
//带小数的会是这个
tkFloat:
forkTemp.FData.Add(key, data[i]);
else
ShowCoreErrorMsg('开发人员书写错误，数据参数仅支持String、Integer、Boolean、Int64、UInt64、Currency、Extended，请核查！');
end;
end;
end;

//完全成功时，返回自己
Result := Self;
end;

function TTask.scopes(scopes: TArray): TTask;
begin
if forkTemp = nil then
begin
ShowCoreErrorMsg('开发人员书写错误，应该先调用bg/ui才能继续！');
end;

if forkTemp.FScopes <> nil then
begin
ShowCoreErrorMsg('开发人员书写错误，禁止scopes().scopes()这种不直观语法，请核查！');
end;

if Length(scopes) = 0 then
begin
//这里不报错，直接退出，有时候为了方便调式会注释掉scopes里的参数
Exit(Self);
end;

//这里先把窗体的指针存入协程，并不验证窗体的指针是否正常，验证的操作交给start，
//因为start需要窗体也挂载上来协程的指针，就好比进入正式环境一样，协程对窗体的
//指针挂载只是临时，且只有start那里能终止执行；
forkTemp.FScopes := TList.Create;
for var f in scopes do
begin
if f = Application.MainForm then
begin
raise Exception.Create('开发人员错误，scopes(主窗体)是没有意义的，主窗体关闭就是程序关闭，这样写是多余的，禁止这样写，请去除主窗体！');
end;
forkTemp.FScopes.Add(f);//这里不需要加锁来添加了，因为还没有开始进入执行阶段
end;

//返回自己
Result := Self;
end;

function TTask.interval(interval: Int64): TTask;
begin
if forkTemp = nil then
begin
ShowCoreErrorMsg('开发人员书写错误，应该先调用bg/ui才能继续！');
end;

if Self.tkind <> TK_ROOT then
begin
ShowCoreErrorMsg('开发人员书写错误，重复执行的协程，只能从根节点衍生！');
end;

//这里不用写了，统一在 .start；root 衍生那里写，这里只是提示下，另外 rpt协程首次也是直接入执行队列的，并不先入 rptList 容器；
// if not isMainThread then
// begin
// ShowCoreErrorMsg('开发人员书写错误，重复执行的协程，只能在主线程里衍生！');
// end;

forkTemp.isRpt := True;
forkTemp.rptInterval := interval;

Result := Self;
end;

function TTask.start: string;
begin
{
边取消，边新增的问题；举例：上层协程在取消，而此协程在生成，你可能会误解的认为，
此时取消和衍生这2个线程再抢这个childsLock，然后又分为谁先拿到锁2种情况，其实不是这样的，
我们的取消是接力棒，若当前协程正在执行，另一个取消线程发现是DOING时，就已经退出了，
取消的操作交给了本线程；所以不存在取消线程与本线程 抢childsLock的问题；且取消是 tryEnter
拿不到锁就退出了，是最大化取消，不是绝对全部取消，不会出现抢锁的问题；
这里要判断下当前协程是否被取消，若被取消了就不要再新增分支了，由于当前协程正在做，若外部
取消只可能是 doing -> canceling 一个协程，已经被其它线程该为 canceling了；此时 协程内部若
需要衍生出大量的子协程的话,应该使用 isCancel方法，及时跳出循环，不再衍生；若开发者没有使用isCancel，
则只在协程的start这里进行拦截，此协程不入执行队列；生成还是照样生成，就是不入队列，生成了 -> 又会
被立即释放，因为A:取消不是常规操作，又加上 B: 此协程需要衍生大量子协程; 又加上 C 开发
者又没有使用isCancel；A + B + C 三个因素情况少见，没有在协程的创建 --> start 全链路都加
if state = canceling 的判断，代码冗余，不利于维护；
}
if state = ST_CANCELING then
begin
//已经创建了的，这里free下，然后再退出，避免有内存泄漏
if forkTemp <> nil then
begin
FreeAndNil(forkTemp);
end;
Exit;
end;

if forkTemp = nil then
begin
ShowCoreErrorMsg('开发人员书写错误，应该先调用bg/ui才能继续！');
end;

//校验作用域，并不检查窗体悬空指针的问题，悬空指针是开发人员的问题，后期观察下 什么情况下会出现悬空指针，从开发人员上杜绝；
if forkTemp.FScopes <> nil then
begin
for var frm in forkTemp.FScopes do
begin
//判断窗体是否处于关闭中，只有主线程可以写窗体的状态，因为关闭操作是windows消息嘛，故不存在多线程的问题；
if frm.isFreeIng then
begin
{
coreErrorShow('开发人员逻辑错误，窗体实例已在关闭中！');
这里并不报错，举例：一个窗体上 有一个 开始按钮，衍生100个协程，然后窗体关闭，应该停止衍生新协程；而不是报错；
}
FreeAndNil(forkTemp); //有一个作用域退出，就不执行，由于是for循环里，这里是要退出，就退出了；
Exit;
end else begin
//动态创建提高效率，并不是所有协程都有作用域
frm.tasksLock.Enter;
if frm.tasks = nil then
begin
frm.tasks := TDictionary<string, TTask>.Create;
end;
//把协程的指针也挂载到form上
frm.tasks.Add(forkTemp.id, forkTemp);
frm.tasksLock.Leave;
end;
end;
end;

{
2.边新增边回收的问题，根本就不会存在这个问题，因为GC线程的回收一定是先判断当前协程的状态
若发现当前协程是Doing是不会去回收的；下游的协程完毕后，GC线程会从本协程的childs里删除
指针关系，故会与当前线程来同时操作childs，所以这里要加锁
}
//动态创建，提高效率，并不是每一个协程都有分叉
childsLock.Enter; //由于gc也在运行着，即使节点还没有slb，操作本节点childs的话要加锁
if childs = nil then
begin
childs := TDictionary<string, TTask>.Create;
end;
childs.Add(forkTemp.id, forkTemp);
childsLock.Leave;

//建立父子关系，这里由于还没有开始执行此协程，故这里不存在多线程有关的任何问题
forkTemp.parent := Self;

{
衍生协程，根据当前协程类型 + 衍生出来的协程类型 分为4种情况：
1. bg -- bg
2. bg -- ui
3. ui -- bg
4. ui -- ui
}
//根据当前协程类型 + 衍生出的新的协程类型，这样一个关系做出处理
case task.tkind of
TK_ROOT: begin

  //通常是开发者的问题，避免 新建一个后台线程或匿名线程，然后在里面使用 task.bg/ui就会导致这个问题；
  if not IsMainThread then
  begin
    ShowCoreErrorMsg('内部核心错误，请联系开发者，ROOT在非主线程中！');
  end;

  {
    通常需要先有窗体，task.scopes 才能进行，这个支持协程的窗体就是为了协程而服务的，所以创建协程窗体也要启动协程；
    1. 创建协程窗体时，启动协程；
    2. 不创建窗体，直接 task.bg.start；start这里分支第一个协程时 也要启动协程；
  }
  if not TASK_IS_RUNING then
  begin
    log('协程启动中...');
    enableTaskThreads;
  end;

  //新建的重复协程，首次也是立即入队列执行的，并不是先入 rptList容器，而是直接入执行队列，所以不用考虑是否是重复协程的问题；
  case forkTemp.tkind of
    TK_BG: gotoBgWaitQueue(forkTemp);

    TK_UI: begin
      //写入主线程容器，这个写入操作，点进入源码你会看到他用了TMonitor锁，我们不用在加锁了
      //这里之所以使用 ForceQueue 是因为，若UI协程A，被主线程运行时，又需要衍生N个子协程，
      //需要新衍生的这些子协程，有的是UI，有的又是BG，若同步执行UI，那么会导致BG会晚衍生，
      //从而浪费多核并发的优势，举例：需要UI_A，运行的过程中，需要衍生出UI_A1, UI_A2，BG_A3,
      //若同步执行，则BG_A3，需要前2个都执行完毕后，才会衍生出，用ForceQueue的话，A3可能会优于
      //A1,A2执行完毕；显然我们需要异步；
      TThread.ForceQueue(nil, forkTemp.outNoArgProc);
    end;
  end;
end;

TK_BG: begin
  case forkTemp.tkind of
    TK_BG: begin
      //优先进入自己的本地队列，本地满写全局
      var wkth := wkThreads.Items[Self.wkThreadIndex];
      wkth.lcWaitQueueLock.Enter;
      if wkth.lcWaitQueue.Count < wkth.lcWaitQueue.Capacity then
      begin
        forkTemp.wkThreadIndex := Self.wkThreadIndex;
        wkth.lcWaitQueue.Enqueue(forkTemp);
        wkth.lcWaitQueueLock.Leave;
      end else begin
        wkth.lcWaitQueueLock.Leave; //先退出本地锁

        //开始写入全局队列
        glWaitQueueLock.Enter;
        glWaitQueue.Enqueue(forkTemp);
        glWaitQueueLock.Leave;
      end;

      AtomicIncrement(WAIT_BG_COUNT); //先入队再 + 1，无论是写入本地还是全局这里都新增 1
    end;

    //这里只需加入队列就可，因为当前一定是bg线程了，不用ForceQueue
    TK_UI: TThread.Queue(nil, forkTemp.outNoArgProc);
  end;
end;

TK_UI: begin
  case forkTemp.tkind of
    TK_BG: gotoBgWaitQueue(forkTemp);

    //当前是主线程用 ForceQueue
    TK_UI: TThread.ForceQueue(nil, forkTemp.outNoArgProc);
  end;
end;

end;

//将当前指针置为nil，上面的指针是入栈，已经存入相应的容器内部，这里指针重置为nil，方便继续衍生；
forkTemp := nil;
end;

procedure TTask.Free;
begin
inherited;
end;

constructor TTaskForm.CreateParented(ParentWindow: HWnd);
begin
raise Exception.Create('开发人员错误，禁止使用 TTaskForm.CreateParented 来创建窗体！');
end;

class function TTaskForm.CreateParentedControl(ParentWindow: HWND): TWinControl;
begin
raise Exception.Create('开发人员错误，禁止使用 TTaskForm.CreateParentedControl 来创建窗体！');
end;

constructor TTaskForm.CreateNew(AOwner: TComponent; Dummy: Integer = 0);
begin
raise Exception.Create('开发人员错误，禁止使用 TTaskForm.CreateNew 来创建窗体！');
inherited;
end;

constructor TTaskForm.CreateScaledNew(AOwner: TComponent; ADPI: Integer = 0; Dummy: Integer = 0);
begin
raise Exception.Create('开发人员错误，禁止使用 TTaskForm.CreateScaledNew 来创建窗体！');
inherited;
end;

constructor TTaskForm.Create(AOwner: TComponent);
begin
if TThread.Current.ThreadID <> MainThreadID then
begin
raise Exception.Create('开发人员错误，创建窗体必须在主线程里进行！');
end;

var isMainForm := False;
//主窗体的时候 Application.MainForm = nil的，不进行校验
if Application.MainForm <> nil then
begin
// aowner 必须为 nil、TTaskForm、控件（如panel，但要求 panel.owner 必须为 TTaskForm）
if (AOwner <> nil) and (AOwner <> Application.MainForm) then
begin
if (not (AOwner is TTaskForm)) and (not (AOwner.Owner is TTaskForm)) then
begin
raise Exception.Create('开发人员错误，AOwner 的类型范围必须为：nil、TTaskForm、AOwner.Owner = TTaskForm 这三种情况，请核查！');
end;
end;
end else begin
isMainForm := True;
{
通常需要先有窗体，task.scopes 才能进行，这个支持协程的窗体就是为了协程而服务的，所以创建协程窗体也要启动协程；
1. 主窗体启动时候，启动协程，有的时候，有登录窗体，登录窗体是在主窗体之前的，登录窗体可能已经把协程启动了，
所以这里还是要判断下
2. 创建协程窗体时，启动协程；
3. 不创建窗体，直接 task.bg.start；start这里分支第一个协程时 也要启动协程；
}
if not TASK_IS_RUNING then
begin
log('协程启动中...');
enableTaskThreads;
end;
end;

inherited Create(AOwner);

//生成一个GUID
Self.id := TGUID.NewGuid.ToString;
//为了使用上不报错，要求锁必须创建时初始化
tasksLock := TCriticalSection.Create;
//只要是TaskForm，就统一入容器，因为 用 taskForm就意味着要用协程机制，所以要加入协程的容器
if not isMainForm then //主窗体不加入这个容器
begin
glTaskFormMap.Add(Self.id, Self);
end;
end;

procedure TTaskForm.SetParent(AParent: TWinControl);
begin
//parent 必须为 nil、控件（如panel，但要求 panel.owner 必须为 TTaskForm）; parent := TTaskForm 或 TForm 没有意义 禁止
if AParent <> nil then
begin
if (AParent is TTaskForm) or (AParent is TForm) then
begin
raise Exception.Create('开发人员错误，Parent := TTaskForm 或 TForm 是没有意义的。起码应该把窗体放进一个容器里，而不是直接窗体；故禁止操作！');
end;

if not (AParent.Owner is TTaskForm) then
begin
  raise Exception.Create('开发人员错误，Parent 必须为 TTaskForm 里的容器，而不是普通的 TForm，请将 Parent对应的容器的 form 继承 TTaskForm！');
end;

end;
inherited;
end;

destructor TTaskForm.Destroy;
begin
//看下是否有挂载

tasksLock.Free;
//taskMap是动态的，默认是nil，当调用.scope的时候才会创建，所以这里判断下
if tasks <> nil then
begin
tasks.Free;
end;

//记录窗体真被释放了，方便调试
log(Self.Caption + ' ----- 真被释放了！');

inherited;
end;

procedure TTaskForm.Free;
begin
//要让开发人员养成良好的编程习惯，故这里不删除
if not isMainThread then
begin
ShowCoreErrorMsg('开发人员错误，销毁窗体必须在主线程里进行！');
end;

{
关于窗体的释放，一共有 parent 和 owner 两个元素 影响释放，分为4种情况：
1. parent(no) + owner(no)，比如 弹出窗体场景：

    with TTaskForm.Create(nil) do
    begin
      ShowModel;
      Free; //走到 free时，用户肯定点击了 frm.close; 所以窗体是已经隐藏了的
    end;

2. parent(yes) + owner(no)，这个少见，与 parent(yes) + owner(yes) 一样，比如：创建一个窗体嵌入另一个窗体的panel上

    with TTaskForm.Create(nil) do
    begin
      parent := panel1;
      Show;
      //Free; 这里写不写 Free 都没有问题，因为指定了 parent 不写 free，最终也会调用 destroy，随 parent；
    end;

3. parent(yes) + owner(yes)；与2 效果一样，比如：创建一个窗体嵌入另一个窗体的panel上，这个比较常用，main 选项卡就是用的这个；

    with TTaskForm.Create(taskform123) do
    begin
      parent := panel1;
      Show;
      //Free; 这里写不写 Free 都没有问题，因为指定了 parent 不写 free，最终也会调用 destroy，随 parent；
    end;

4. parent(no) + owner(yes)  这个更加少见，创建一个窗体 随另一个窗体释放，但却不再另一个窗体的容器里展示；奇怪 比较少见；

----------------------------------

2、3、4 这3种情况，都是把自己挂载到另一个 TTaskForm上，那么就意味着 最顶层的 TTaskForm.free 一定先执行，就是说 这4种 情况，都是

TTaskForm.Free 在先，然后 gc 回收 task 然后 通知 main 再回收 form.destroy，可见 free 一定是在 destroy 前的，我们把主窗体 也设计成 TTaskForm,
因为主窗体也要挂载其它 TTaskForm，所以 最顶层的一定是 TTaskForm.free 在先；主窗体那里 我们看下 如何做到 主窗体 关闭的时候，先调用 mainForm.free;

}

//开始递归，parent 或 owner 只要指定一个，就会向下递归
freeTaskForm(Self);
end;

procedure TTaskFormTabsBar.MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
//逐步向下条件，直到满足所有条件，总之 inherited 一定会被执行一次；让父类做一些其它的重置操作；

//1.不是左键就调用父类的方法；
if Button <> mbLeft then
begin
inherited;
Exit;
end;

//2.若根本都没有展示关闭按钮，则也是调用父类的然后退出
if not Self.TabOptions.ShowCloseButton then
begin
inherited;
Exit;
end;

//3.获取鼠标点击的 tab，获取不到 说明不是在tab点击的，而是在 tabbar空白区域点击的
var tab := Self.TabFromPoint(TPoint.Create(x, y));
if tab = nil then
begin
inherited;
Exit;
end;
var frm := tab.Form;

//4.看下点击的是否是 tab右上方的关闭按钮
if tab.CloseButtonMouseIn then
begin
//去除 form 的 onclose事件，不允许开发人员 干涉选项卡的关闭，就好比浏览器的选项卡，禁止程序员让其不关闭一样；
frm.OnClose := nil;
frm.OnCloseQuery := nil;

{
  先调用官方的，进行一些后置操作，其实官方的 就是 form.close; close 就是 执行用户自定义的 onclose事件代码 + hide 当前窗体
  onclose事件我们已经去除了，其实官方的就是 FMouseCaptureTab.FCloseButtonMouseDown := False; FMouseCaptureTab := nil;等一些
  重置操作；
}
inherited;

//由于 hide ，还是存在，会导致 tab上 还是有这个窗体，我们直接从 tab上摘除这个窗体
Self.DeleteForm(frm);

//然后调用窗体的free方法；1. 修改状态 isFreeIng = true; 2. 解除 parent 和 owner关系; 3. 取消协程; 然后什么都不做，并不真正释放，而是让主线程来定时释放，这是一个假 free 动作；
TTaskForm(frm).Free;

end else begin
//不是关闭窗体，就只交给父类就行了
inherited;
end;
end;

///

initialization

{
创建根节点：
1.有了根节点，开发者才能使用 task
3.根节点不加入队列，则不会执行，无需proc kind state 等。
3.根节点的作用域为 nil，不创建。
4.根节点可以写入一些根部数据，方便子节点回溯时，查到一些基础数据，这里暂时没有想到要写入哪些数据。
}
task := TTask.Create;
task.tkind := TK_ROOT;

finalization

{
走到这里说明程序关闭了，而程序的关闭是Form右上方的关闭按钮或其他，总之Windows需要
发送关闭进程的消息给程序，关闭程序进程操作系统会回收进程资源，所有我们不用担心内存
泄漏什么的，但是假如我们的程序有泄漏，而我们自己又不知道，在程序不关闭的情况下可能
耗完内存，所以我们通常会 ReportMemoryLeaksOnShutdown := True; 让程序关闭的时候提示
一下内存泄漏，方便我们调试; 我们应该在程序关闭时，清空所有我们应该清空的内存，不要
让其关闭时，报内存泄漏错误；

另外留意：主线程 是有2个队列的，一个是windows消息队列，一个是我们的协程队列，一旦
windows消息队列执行到关闭程序这个消息了，其实协程队列是不会执行的了，因为主线程优先
处理Windows消息队列，空闲的时候才会处理协程队列，而消息队列是个关闭程序的消息，代码
会走到这里，根本不会去执行协程队列；所以可以在这里终结所有后台线程，一切交给主线程
来断后，做一些清理工作，遍历整个协程树全部释放；
}

//=================== 反过来，先释放线程，再释放容器 ====================

//若当前协程机制正在运行，才有线程可以释放，默认协程机制是关闭的
if TASK_IS_RUNING then
begin
//这里很多线程还都在运行着，要原子操作写
TInterlocked.Exchange(TASK_IS_RUNING, False);

//WaitFor若线程已经结束会立即返回，没有结束会阻塞在这里，看博客；
//先停止 GC 和 rpt 线程
gcThread.WaitFor;
rptThread.event.SetEvent;
rptThread.WaitFor;
for var wkth in wkThreads do
begin
  wkth.WaitFor;
end;

//线程都停下来后，再统一释放，避免 wk线程 互相偷同事的问题，还都没停下来就释放，
//导致A去偷B的，结果B的容器释放了的问题
gcThread.Free;
rptThread.Free;
for var wkth in wkThreads do
begin
  wkth.Free;
end;
wkThreads.Free;

//开始释放容器，这里就没有必要加锁了
glWaitQueue.Free;
glWaitQueueLock.Free;

glRptList.Free;
glRptListLock.Free;

mainDoneMap.Free;
mainDoneMapLock.Free;
rptDoneMap.Free;
rptDoneMapLock.Free;

{
  glTaskFormMap 的释放，流程是：主窗体Close ---> 主窗体Destroy ---> owner或parent在自己上的子窗体 destroy ---> 走到本单元的finalization；
  由于走到本单元的 finalization 时，凡是主窗体与选项卡还没有解绑的，实际上已经被main窗体连带释放，所以 glTaskFormMap的
  释放会有问题，若关闭主程序则先解绑 主窗体与选项卡的绑定，然后再走下面的路程来释放 所有 TTaskForm;
  就是说 glTaskFormMap 容器里 不能存在 2种生命周期的窗体，走到这里时必须统一管理；否则这里代码是没法写的；
  我们已经在 enableTaskThreads 协程启动时，给主窗体绑定事件，关闭主窗体时，先解除与所有TTaskForm的绑定，避免关闭主窗体
  这些选项卡一并随主窗体释放了，再去遍历 glTaskFormMap 释放元素时会有异常；Application.MainForm.OnDestroy := task.mainDestroy;
  这里可以统一直接释放了；
}
for var frm in glTaskFormMap.Values do
begin
  frm.Free; //先全部 free 下，解除互相之间的关系，避免连带释放；
end;
for var frm in glTaskFormMap.Values do
begin
  frm.Destroy; //调用的是 destroy ，因为 free 是假free；
end;
glTaskFormMap.Free;

end;

//最后释放整颗协程树，从root开始向下递归，包含 root，这句是无论协程是否运行都得有这句，因为肯定有 root 存在
terminateTask(task);

end.