// 用于保存 bthread 的 ids
std::vector<bthread_t> tids(3);
for (size_t i = 0; i < tids.size(); ++i) {
    // 开启后台 bthread，开启的 bthread id 保存在 tid[i] 中
    bthread_start_background(&tids[i], nullptr, fn, arg);
}
std::vector<void*> res(tids.size());
for (size_t i = 0; i < tids.size(); ++i) {
    // 等待执行结束，返回值保存在 res[i] 中
    bthread_join(tids[i], &res[i]);
}

class TaskGroup {
    // ...
    size_t _steal_seed; // work stealing 算法随机数种子
    size_t _steal_offset; // work stealing 算法随机数偏移量
    
    // main bthread，调度线程
    ContextualStack* _main_stack;
    bthread_t _main_tid;
    
    WorkStealingQueue<bthread_t> _rq; // 通过 worker 添加
    RemoteTaskQueue _remote_rq; // 非 worker 添加
};

void TaskGroup::run_main_task() {
    TaskGroup* dummy = this;
    bthread_t tid;
    while (wait_task(&tid)) {
        TaskGroup::sched_to(&dummy, tid);
        // ...
        if (_cur_meta->tid != _main_tid) {
            TaskGroup::task_runner(1);
        }
        // ...
    }
}

bool TaskGroup::wait_task(bthread_t* tid) {
    // 1. 等待 parking lot，可以理解为一个 bthread 到来的条件变量
    // 2. 执行 steal_task(tid)，成功返回 true
}

bool TaskGroup::steal_task(bthread_t* tid) {
    // 1. 优先从本 _remote_rq 中获取
    if (_remote_rq.pop(tid)) {
        return true;
    }
    // ...
    // _control 是本 TaskGroup 所属的 TaskControl 指针
    return _control->steal_task(tid, &_steal_seed, _steal_offset);
}

bool TaskControl::steal_task(bthread_t* tid, size_t* seed, size_t offset) {
    bool stolen = false;
    size_t s = *seed;
    // ngroup 是所有 TaskGroup 的数量
    for (size_t i = 0; i < ngroup; ++i, s += offset) {
        // _groups 数组保存所有该 TaskControl 下的 TaskGroup 指针
        TaskGroup* g = _groups[s % ngroup];
        if (g) {
            // 2. 从随机 TaskGroup 的 _rq 队列中取
            if (g->_rq.steal(tid)) {
                stolen = true;
                break;
            }
            // 3. 从随机 TaskGroup 的 _remote_rq 中取
            if (g->_remote_rq.pop(tid)) {
                stolen = true;
                break;
            }
        }
    }
    // ...
    // 更新随机数种
    *seed = s;
    return stolen;
}

void TaskGroup::sched_to(TaskGroup** pg, TaskMeta* next_meta) {
    TaskGroup* g = *pg;
    ...
    // Switch to the task
    // cur_meta 是当前执行的 TaskMeta
    // __builtin_expect(next_meta != cur_meta, 1) 的意思是极大可能 next_meta != cur_meta，在此处是绝不可能
    // __builtin_expect 用于编译器优化条件分支语句
    if (__builtin_expect(next_meta != cur_meta, 1)) {
        ...
        if (cur_meta->stack != NULL) {
            if (next_meta->stack != cur_meta->stack) {
                // 切换栈
                jump_stack(cur_meta->stack, next_meta->stack);
            }
            ...
        }
    } else {
        LOG(FATAL) << "bthread=" << g->current_tid() << " sched_to itself!";
    }
    ...
}

void TaskGroup::task_runner(intptr_t skip_remained) {
    TaskGroup* g = tls_task_group;
    do {
        // 当前运行 bthread 上下文
        TaskMeta* const m = g->_cur_meta;
        ...
        执行 bthread 函数
        ...
        // 执行 ending_sched
        ending_sched(&g);
    } while (g->_cur_meta->tid != g->_main_tid);
}

void TaskGroup::ending_sched(TaskGroup** pg) {
    TaskGroup* g = *pg;
    bthread_t next_tid = 0;
    ...
    const bool popped = g->_rq.steal(&next_tid);
    if (!popped && !g->steal_task(&next_tid)) {
        // _rq 已经没有任务并且其他 TaskGroup 也没有任务时
        // 重置为 main bthread
        next_tid = g->_main_tid;
    }
    TaskMeta* const cur_meta = g->_cur_meta;
    TaskMeta* next_meta = address_meta(next_tid);
    ...
    sched_to(pg, next_meta);
}