纯C++无阻塞循环设计方案咨询（ESP32/Arduino无线程环境）

在纯C++环境（运行于ESP32，无线程支持）下，有如下阻塞式递归循环函数：

void do_something_for_a_long_time(vector a) {
  for(int i=0; i < 1000; i++) {
    for(int j=0; j < 1000; j++) {
      if(a.start == a.end) {
        // 递归深入
        do_something_for_a_long_time(a[1]);
      } else {
        // 递归终止，处理vector
        // do something with vector
      }
    }
  }
}

核心逻辑是通过多层循环+递归完成计算，但运行在Arduino环境中必须避免阻塞，需要将其转换为无阻塞计算，实现如下调用形式：

void loop() {
  // 频繁调用
  do_something_non_blocking(...);
  // 执行其他任务
  // other stuff
}

要求每次调用无阻塞函数时仅执行一小步计算，通过反复调用替代单次阻塞等待，同时希望找到通用简洁的方案，而非针对该场景的复杂状态机。

已有思路：

• 将for循环拆分为三个阶段：
  • 初始化（init）
  • 主体（body）
  • 退出（exit）
• 编写宏库封装状态机逻辑

针对这类嵌套循环+递归的阻塞逻辑，最通用的简洁方案是手动保存执行上下文，将递归和循环的状态封装为对象，每次调用无阻塞函数时恢复状态、执行一步、再保存状态。

1. 上下文状态封装 #

定义结构体保存所有需要跟踪的状态，包括循环计数器、递归层级栈和计算完成标记：

struct CalculationContext {
  // 循环计数器
  int i = 0;
  int j = 0;
  // 递归帧：保存每层的vector和当前循环状态
  struct RecursionFrame {
    vector a;
    int i;
    int j;
  };
  std::stack<RecursionFrame> recursion_stack;
  // 当前处理的vector
  vector current_a;
  // 计算完成标记
  bool is_done = false;

  // 初始化上下文
  void init(vector initial_a) {
    current_a = initial_a;
    i = 0;
    j = 0;
    is_done = false;
    while (!recursion_stack.empty()) recursion_stack.pop();
  }
};

2. 无阻塞函数实现 #

基于上下文结构体，每次调用仅执行一个循环迭代或递归切换步骤：

void do_something_non_blocking(CalculationContext& ctx) {
  if (ctx.is_done) return;

  // 处理当前层级的外层循环
  if (ctx.i < 1000) {
    // 处理当前层级的内层循环
    if (ctx.j < 1000) {
      if (ctx.current_a.start == ctx.current_a.end) {
        // 递归：保存当前状态到栈，切换到子vector
        ctx.recursion_stack.push({ctx.current_a, ctx.i, ctx.j});
        ctx.current_a = ctx.current_a[1];
        ctx.i = 0;
        ctx.j = 0;
      } else {
        // 执行一次vector处理逻辑
        // do something with ctx.current_a

        // 推进内层循环计数器
        ctx.j++;
      }
    } else {
      // 内层循环结束，重置计数器并推进外层循环
      ctx.j = 0;
      ctx.i++;
    }
  } else {
    // 当前层级外层循环结束，检查是否需要返回上一层递归
    if (!ctx.recursion_stack.empty()) {
      auto frame = ctx.recursion_stack.top();
      ctx.recursion_stack.pop();
      ctx.current_a = frame.a;
      ctx.i = frame.i;
      ctx.j = frame.j + 1; // 从下一个内层循环步继续
    } else {
      // 所有层级计算完成
      ctx.is_done = true;
    }
  }
}

3. Arduino环境调用方式 #

在loop中频繁调用无阻塞函数，同时并行执行其他任务：

CalculationContext ctx;
bool calculation_started = false;

void setup() {
  // 初始化初始vector
  vector initial_a = ...;
  ctx.init(initial_a);
  calculation_started = true;
}

void loop() {
  if (calculation_started && !ctx.is_done) {
    do_something_non_blocking(ctx);
  }
  // 执行其他任务，比如传感器读取、串口通信等
  // other stuff
}

4. 通用封装优化（可选） #

如果需要批量处理同类问题，可以用模板类或宏封装状态机逻辑，减少重复代码。例如封装循环状态跟踪的宏：

#define NON_BLOCKING_LOOP(var, start, end, ctx, body) \
  if (ctx.var < end) { \
    body; \
    ctx.var++; \
    return; \
  } else { \
    ctx.var = start; \
  }

不过宏可读性较差，更推荐用模板类封装通用的循环/递归上下文管理逻辑，适配不同的计算场景。

关键注意事项 #

• 所有循环计数器、递归层级状态必须持久化保存，不能放在函数栈上
• 每次调用仅执行最小计算单元（比如一次循环迭代或一次递归切换）
• 用栈结构模拟递归调用栈，手动管理递归层级的进入与返回

内容的提问来源于stack exchange，提问作者muebau