NodeMCU eLua中coroutine.yield是否归还控制权给SDK及协程问询

Answers to Your NodeMCU eLua Coroutine Questions #

Great question—let’s break this down clearly, since NodeMCU’s eLua environment ties coroutines closely to its SDK task model, which you’ve already referenced from the docs and Programming in Lua (PiL).

1. Does coroutine.yield(c) return control to the SDK? #

Yes, absolutely. Here’s why:

• NodeMCU’s SDK uses a non-preemptive task queue—tasks run to completion unless they explicitly yield control.
• When you call coroutine.yield() from within a coroutine, you’re not just suspending the coroutine itself—you’re also yielding control back to the SDK’s task scheduler. This lets the SDK process other queued events (like network callbacks, timer triggers, or I/O operations) before resuming your coroutine later.
• Unlike a standard Lua environment where yield only passes control between coroutines, NodeMCU’s eLua integrates coroutines with the SDK’s event loop. Yielding is the only way to let the SDK handle other tasks mid-coroutine execution.

2. Can this be used to implement cooperative multithreading? #

Definitely! Cooperative multithreading relies on tasks voluntarily yielding control to each other, which is exactly what NodeMCU’s coroutines enable.

• You can create multiple coroutines that represent different "threads" of work (e.g., one handling sensor reads, another managing network communication).
• By calling coroutine.yield() at strategic points in each coroutine (after completing a small chunk of work), you let the SDK switch between them (and handle other system tasks) in a cooperative way.
• For example:

  local coro1 = coroutine.create(function()
    while true do
      print("Coro 1 working...")
      coroutine.yield()
    end
  end)
  
  local coro2 = coroutine.create(function()
    while true do
      print("Coro 2 working...")
      coroutine.yield()
    end
  end)
  
  -- Alternate resuming coroutines via a timer scheduler
  tmr.create():alarm(1000, tmr.ALARM_AUTO, function()
    coroutine.resume(coro1)
    coroutine.resume(coro2)
  end)
  

  This setup lets both coroutines run in a cooperative fashion, with the timer acting as a simple trigger to switch between them.

3. How does coroutine.resume(c) work in NodeMCU/eLua? #

The behavior aligns with standard Lua, but with key ties to the SDK’s task model:

• First call to resume: Starts the coroutine c and runs it until it hits the first coroutine.yield() or completes. If it yields, resume returns true plus any values passed to yield. Control then returns to the context that called resume (which could be the main Lua thread or another coroutine), and the SDK can process other tasks.
• Subsequent calls to resume: Resumes the coroutine from the exact point where it yielded. Any arguments passed to resume are returned as values from the yield call in the coroutine. The coroutine then runs until the next yield or completion.
• Important note: If you call resume from within an SDK-triggered callback (like a timer or network event), the SDK treats the coroutine execution as part of that callback task. When the coroutine yields, the callback task completes, and the SDK goes back to processing its event queue. When you call resume again later, it’s treated as a new continuation task in the queue.

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