别再学协程异步了！先搞懂什么是例程

// src/libcephfs.cc
extern "C" int ceph_ll_read(class ceph_mount_info *cmount, Fh* filehandle,
                            int64_t off, uint64_t len, char* buf)
{
    // 1. 入口：调用时从这里开始执行
    bufferlist bl;  // 在当前线程栈上创建局部变量
    int r = 0;
    
    // 2. 线性执行：按顺序调用内部例程
    r = cmount->get_client()->ll_read(filehandle, off, len, &bl);
    
    if (r >= 0) {
        // 3. 继续线性执行：处理返回结果
        bl.copy(0, bl.length(), buf);
        r = bl.length();
    }
    
    // 4. 唯一出口：执行到这里结束，返回结果
    return r;
    // 5. 栈帧销毁：局部变量bl和r被自动释放
}

// MySQL的同步查询例程
int mysql_query(MYSQL *mysql, const char *sql)
{
    // 发送查询请求到服务器
    int r = send_query(mysql, sql);
    if (r != 0) {
        return r;
    }
    
    // 阻塞等待服务器响应
    r = read_query_result(mysql);
    
    return r;
}

┌─────────────────────────────────────────────────────────────────┐
│                     异步编程范式（Asynchronous）                 │
│  ┌─────────────────────┐  ┌──────────────────────────────────┐ │
│  │  回调式异步         │  │  协程式异步                      │ │
│  │  (Callback-based)   │  │  (Coroutine-based)               │ │
│  └─────────────────────┘  └──────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
                              ▲
                              │
┌─────────────────────────────────────────────────────────────────┐
│                     执行载体（Execution Carriers）              │
│  ┌─────────────────────┐  ┌──────────────────────────────────┐ │
│  │  线程（Thread）     │  │  协程（Coroutine）                │ │
│  │  内核态调度         │  │  用户态调度                      │ │
│  │  抢占式             │  │  协作式                          │ │
│  └─────────────────────┘  └──────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
                              ▲
                              │
┌─────────────────────────────────────────────────────────────────┐
│                     基础执行单元（Basic Unit）                  │
│  ┌──────────────────────────────────────────────────────────┐ │
│  │  例程（Routine）                                        │ │
│  │  函数/方法/子程序/回调函数                              │ │
│  │  调用-执行-返回 线性流                                  │ │
│  │  所有软件的基石                                        │ │
│  └──────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘

auto data = std::make_shared<std::string>("important");


auto *ctx = new LambdaContext([data](int r) {
  std::cout << *data << std::endl;
});

#include <iostream>
#include <functional>
#include <thread>
#include <chrono>

// 模拟 Ceph 的 Context 基类
class Context {
public:
    // 异步操作完成后调用 complete，默认会调用 finish 并删除自己
    void complete(int r) {
        finish(r);
        delete this;   // 关键：回调执行后自毁
    }
protected:
    // 子类实现自己的回调逻辑
    virtual void finish(int r) = 0;
    virtual ~Context() {}   // 虚析构，允许子类正确析构
};

// 模拟 LambdaContext，把用户 lambda 包进去
template<typename F>
class LambdaContext : public Context {
    F f;
public:
    LambdaContext(F &&f_) : f(std::forward<F>(f_)) {}
protected:
    void finish(int r) override {
        f(r);   // 执行用户逻辑
    }
};

// 一个简单的异步任务模拟器，类似 Objecter
class AsyncOpRunner {
public:
    // 提交异步操作，稍后会在另一个线程里触发回调
    void submit(Context *ctx) {
        // 这里用线程模拟异步回调
        std::thread([ctx]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            // 模拟操作完成，返回码 0
            ctx->complete(0);
        }).detach();
    }
};

// ==================== 正确示例：按值捕获 ====================
void correct_async_op() {
    std::string data = "important_data";

    // 创建 LambdaContext，按值捕获 data 的副本
    Context *ctx = new LambdaContext([data](int r) {
        // 此时 data 是闭包内部的副本，生命周期与闭包一致
        std::cout << "Callback: data = " << data << ", result = " << r << std::endl;
    });

    AsyncOpRunner runner;
    runner.submit(ctx);

    // data 局部变量在这里会被析构，但闭包里的副本还活着
    std::cout << "Submitted, data local will be destroyed soon.\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(200)); // 等回调执行完
}

// ==================== 错误示例：引用捕获 ====================
void incorrect_async_op() {
    std::string data = "dangerous_data";

    // 引用捕获！危险！
    Context *ctx = new LambdaContext([&data](int r) {
        // 回调在另一个线程执行时，data 已经被析构 → 悬空引用
        std::cout << "Callback: data = " << data << ", result = " << r << std::endl;
    });

    AsyncOpRunner runner;
    runner.submit(ctx);

    // data 在此函数返回后析构，但回调可能还没执行
}

int main() {
    std::cout << "== Correct async example ==" << std::endl;
    correct_async_op();

    std::cout << "== Incorrect async example (may crash) ==" << std::endl;
    incorrect_async_op(); // 可能崩溃或打印垃圾
    std::this_thread::sleep_for(std::chrono::milliseconds(200)); // 等未定义行为发生
    return 0;
}

// 调用者 Context是base 类 继承法类 LambdaContext
Context *ctx = new LambdaContext([data](int r) {
    std::cout << "Callback: data = " << data << ", result = " << r << std::endl;
});
调用对象（lambda、函数指针等）
// 交给异步模块
runner.submit(ctx);

// 这是框架（如 Finisher 或 Objecter）最终调用的
void Context::complete(int r) {
    finish(r);
    delete this;   // 回调执行完后自动销毁
}

Context *ctx = new LambdaContext([data](int r) {
    std::cout << "Callback: data = " << data << ", result = " << r << std::endl;
});

template<typename F>
class LambdaContext : public Context {
    F f;   // ← 这是它的核心成员变量！
public:
    LambdaContext(F &&f_) : f(std::forward<F>(f_)) {}

protected:
    void finish(int r) override {
        f(r);   // 调用存储的回调
    }
};

// src/include/Context.h
class C_Lambda : public Context {
    std::function<void(int)> f;
public:
    C_Lambda(std::function<void(int)> &&f_) : f(std::move(f_)) {}
    void finish(int r) override { f(r); }
};

new C_Lambda([data](int r) { ... });

1.  这个技术出现的背景、初衷和要达到什么样的目标或是要解决什么样的问题
    
 这个问题非常关键，也就是说，
 你在学习一个技术的时候，需要知道这个技术的成因和目标，
 也就是这个技术的灵魂。
 如果不知道这些的话，那么你会看不懂这个技术的一些设计理念。

2.  这个技术的优势和劣势分别是什么，或者说，这个技术的 trade-off 是什么

任何技术都有其好坏，在解决一个问题的时候，也会带来新的问题。
另外，一般来说，任何设计都有 trade-off（要什么和不要什么），
所以，你要清楚这个技术的优势和劣势，以及带来的挑战。

3.  这个技术适用的场景
    
任何技术都有其适用的场景，离开了这个场景，这个技术可能会有很多槽点
，所以学习技术不但要知道这个技术是什么，还要知道其适用的场景。没有任何一个技术是普适的。
注意，所谓场景一般分为两个，一个是业务场景，一个是技术场景。

4. 技术的组成部分和关键点
    

这是技术的核心思想和核心组件了，也是这个技术的灵魂所在了
学习技术的核心部分是快速掌握关键。

5.  技术的底层原理和关键实现
    

任何一个技术都有其底层的关键基础技术，这些关键技术很可能也是其它技术的关键基础技术。
所以，学习这些关键的基础底层技术，可以让你未来很快地掌握其它技术。
可以参考我在 CoolShell 上写的 Docker 底层技术那一系列文章。

6.  已有的实现和它们之间的对比

一般来说，任何一个技术都会有不同的实现，不同的实现都会有不同的侧重。
学习不同的实现，可以让你得到不同的想法和思路，对于开阔思维，深入细节是非常重要的。