C++任务调度与状态机

一、任务调度基础

1.1 什么是任务调度？

核心概念：

任务调度就是管理"谁什么时候做什么事"
就像餐厅的前台：接收订单（任务），分配给厨师（线程）处理

1.2 最简单的任务调度 - 使用 std::thread

cpp 复制代码

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

// 定义一个任务
void task1() {
    std::cout << "任务1开始执行" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "任务1执行完成" << std::endl;
}

void task2(int value) {
    std::cout << "任务2开始执行，参数: " << value << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "任务2执行完成" << std::endl;
}

int main() {
    std::cout << "=== 入门级：基础线程使用 ===" << std::endl;
    
    // 创建线程执行任务
    std::thread t1(task1);
    std::thread t2(task2, 42);
    
    // 等待线程完成（必须！）
    t1.join();
    t2.join();
    
    std::cout << "所有任务完成" << std::endl;
    return 0;
}

关键知识点：

std::thread：创建线程
join()：等待线程完成（阻塞调用线程）
detach()：分离线程（不等待，线程独立运行）

1.3 使用 std::async 简化异步任务

cpp 复制代码

#include <iostream>
#include <future>
#include <chrono>

int computeSquare(int x) {
    std::cout << "计算 " << x << " 的平方..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return x * x;
}

std::string fetchData() {
    std::cout << "获取数据..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return "重要数据";
}

int main() {
    std::cout << "=== 入门级：std::async 异步任务 ===" << std::endl;
    
    // 异步执行任务，返回 future
    auto future1 = std::async(computeSquare, 5);
    auto future2 = std::async(fetchData);
    
    // 继续做其他事情
    std::cout << "主线程继续执行其他工作..." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    
    // 获取结果（会阻塞直到任务完成）
    int result1 = future1.get();
    std::string result2 = future2.get();
    
    std::cout << "结果1: " << result1 << std::endl;
    std::cout << "结果2: " << result2 << std::endl;
    
    return 0;
}

关键知识点：

std::async：自动创建线程执行任务
std::future：获取异步任务的结果
get()：阻塞等待结果

1.4 实战：简单的定时任务调度器

cpp 复制代码

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

class SimpleScheduler {
private:
    std::vector<std::pair<std::function<void()>, int>> tasks; // 任务和延迟时间
    std::mutex mutex;
    bool running;
    std::thread scheduler_thread;
    
public:
    SimpleScheduler() : running(false) {}
    
    // 添加定时任务
    void schedule(const std::function<void()>& task, int delay_seconds) {
        std::lock_guard<std::mutex> lock(mutex);
        tasks.emplace_back(task, delay_seconds);
        std::cout << "任务已添加，将在 " << delay_seconds << " 秒后执行" << std::endl;
    }
    
    // 启动调度器
    void start() {
        running = true;
        scheduler_thread = std::thread([this]() {
            while (running) {
                std::this_thread::sleep_for(std::chrono::seconds(1));
                
                std::lock_guard<std::mutex> lock(mutex);
                for (auto& task : tasks) {
                    if (task.second > 0) {
                        task.second--;
                        if (task.second == 0) {
                            task.first(); // 执行任务
                        }
                    }
                }
                
                // 清理已完成的任务
                tasks.erase(
                    std::remove_if(tasks.begin(), tasks.end(), 
                        [](const auto& t) { return t.second == 0; }),
                    tasks.end()
                );
            }
        });
    }
    
    // 停止调度器
    void stop() {
        running = false;
        if (scheduler_thread.joinable()) {
            scheduler_thread.join();
        }
    }
    
    ~SimpleScheduler() {
        stop();
    }
};

int main() {
    std::cout << "=== 入门级：定时任务调度器 ===" << std::endl;
    
    SimpleScheduler scheduler;
    scheduler.start();
    
    // 添加几个定时任务
    scheduler.schedule([]() {
        std::cout << "[3秒] 发送邮件通知" << std::endl;
    }, 3);
    
    scheduler.schedule([]() {
        std::cout << "[5秒] 备份数据库" << std::endl;
    }, 5);
    
    scheduler.schedule([]() {
        std::cout << "[2秒] 检查系统状态" << std::endl;
    }, 2);
    
    // 等待所有任务完成
    std::this_thread::sleep_for(std::chrono::seconds(6));
    
    scheduler.stop();
    std::cout << "调度器已停止" << std::endl;
    
    return 0;
}

二、状态机基础

2.1 什么是状态机？

生活中的例子：

电灯开关：开 ↔ 关
电梯：上升 → 停止 → 下降
订单：待支付 → 已支付 → 已发货 → 已完成

核心要素：

状态（State）：系统当前所处的情况
事件（Event）：触发状态变化的原因
转换（Transition）：从一个状态到另一个状态
动作（Action）：转换时执行的操作

2.2 最简单的状态机 - if-else 实现

cpp 复制代码

#include <iostream>
#include <string>

enum class TrafficLightState {
    RED,
    GREEN,
    YELLOW
};

class TrafficLight {
private:
    TrafficLightState current_state;
    
public:
    TrafficLight() : current_state(TrafficLightState::RED) {
        std::cout << "交通灯初始化：红灯" << std::endl;
    }
    
    void handleTimer() {
        if (current_state == TrafficLightState::RED) {
            std::cout << "红灯 → 绿灯" << std::endl;
            current_state = TrafficLightState::GREEN;
        }
        else if (current_state == TrafficLightState::GREEN) {
            std::cout << "绿灯 → 黄灯" << std::endl;
            current_state = TrafficLightState::YELLOW;
        }
        else if (current_state == TrafficLightState::YELLOW) {
            std::cout << "黄灯 → 红灯" << std::endl;
            current_state = TrafficLightState::RED;
        }
    }
    
    std::string getState() const {
        switch (current_state) {
            case TrafficLightState::RED: return "红灯";
            case TrafficLightState::GREEN: return "绿灯";
            case TrafficLightState::YELLOW: return "黄灯";
            default: return "未知";
        }
    }
};

int main() {
    std::cout << "=== 入门级：交通灯状态机（if-else） ===" << std::endl;
    
    TrafficLight light;
    
    for (int i = 0; i < 6; ++i) {
        std::cout << "\n第 " << (i + 1) << " 次定时器触发：" << std::endl;
        light.handleTimer();
        std::cout << "当前状态: " << light.getState() << std::endl;
    }
    
    return 0;
}

2.3 改进：使用 switch-case 的状态机

cpp 复制代码

#include <iostream>
#include <string>

enum class DoorState {
    CLOSED,
    OPENING,
    OPEN,
    CLOSING
};

class AutomaticDoor {
private:
    DoorState current_state;
    
public:
    AutomaticDoor() : current_state(DoorState::CLOSED) {
        std::cout << "自动门初始化：关闭" << std::endl;
    }
    
    void handleEvent(const std::string& event) {
        std::cout << "\n事件: " << event << std::endl;
        
        switch (current_state) {
            case DoorState::CLOSED:
                if (event == "button_pressed") {
                    std::cout << "关闭 → 正在打开" << std::endl;
                    current_state = DoorState::OPENING;
                    startOpening();
                }
                break;
                
            case DoorState::OPENING:
                if (event == "fully_opened") {
                    std::cout << "正在打开 → 打开" << std::endl;
                    current_state = DoorState::OPEN;
                    startTimer();
                }
                break;
                
            case DoorState::OPEN:
                if (event == "timer_expired" || event == "close_button") {
                    std::cout << "打开 → 正在关闭" << std::endl;
                    current_state = DoorState::CLOSING;
                    startClosing();
                }
                break;
                
            case DoorState::CLOSING:
                if (event == "fully_closed") {
                    std::cout << "正在关闭 → 关闭" << std::endl;
                    current_state = DoorState::CLOSED;
                } else if (event == "obstacle_detected") {
                    std::cout << "检测到障碍物，重新打开" << std::endl;
                    current_state = DoorState::OPENING;
                    startOpening();
                }
                break;
        }
        
        std::cout << "当前状态: " << getStateName() << std::endl;
    }
    
    std::string getStateName() const {
        switch (current_state) {
            case DoorState::CLOSED: return "关闭";
            case DoorState::OPENING: return "正在打开";
            case DoorState::OPEN: return "打开";
            case DoorState::CLOSING: return "正在关闭";
            default: return "未知";
        }
    }
    
private:
    void startOpening() { std::cout << "  执行: 启动开门电机" << std::endl; }
    void startClosing() { std::cout << "  执行: 启动关门电机" << std::endl; }
    void startTimer() { std::cout << "  执行: 启动保持打开定时器（5秒）" << std::endl; }
};

int main() {
    std::cout << "=== 入门级：自动门状态机（switch-case） ===" << std::endl;
    
    AutomaticDoor door;
    
    // 模拟自动门的完整周期
    door.handleEvent("button_pressed");    // 用户按下开门按钮
    door.handleEvent("fully_opened");      // 门完全打开
    door.handleEvent("timer_expired");     // 定时器超时，开始关闭
    door.handleEvent("fully_closed");      // 门完全关闭
    
    // 模拟障碍物检测
    std::cout << "\n--- 模拟障碍物检测 ---" << std::endl;
    door.handleEvent("button_pressed");
    door.handleEvent("fully_opened");
    door.handleEvent("obstacle_detected"); // 检测到障碍物
    door.handleEvent("fully_opened");
    door.handleEvent("timer_expired");
    door.handleEvent("fully_closed");
    
    return 0;
}

2.4 实战：简单的订单状态机

cpp 复制代码

#include <iostream>
#include <string>

enum class OrderStatus {
    DRAFT,        // 草稿
    PENDING,      // 待支付
    PAID,         // 已支付
    SHIPPED,      // 已发货
    COMPLETED,    // 已完成
    CANCELLED     // 已取消
};

class SimpleOrder {
private:
    OrderStatus status;
    std::string order_id;
    
public:
    SimpleOrder(const std::string& id) : order_id(id), status(OrderStatus::DRAFT) {
        std::cout << "订单 " << order_id << " 创建，状态: " << getStatusName() << std::endl;
    }
    
    bool submit() {
        if (status != OrderStatus::DRAFT) {
            std::cout << "错误: 只能从草稿状态提交" << std::endl;
            return false;
        }
        status = OrderStatus::PENDING;
        std::cout << "订单 " << order_id << " 已提交，状态: " << getStatusName() << std::endl;
        return true;
    }
    
    bool pay() {
        if (status != OrderStatus::PENDING) {
            std::cout << "错误: 只能从未支付状态支付" << std::endl;
            return false;
        }
        status = OrderStatus::PAID;
        std::cout << "订单 " << order_id << " 已支付，状态: " << getStatusName() << std::endl;
        return true;
    }
    
    bool ship() {
        if (status != OrderStatus::PAID) {
            std::cout << "错误: 只能从已支付状态发货" << std::endl;
            return false;
        }
        status = OrderStatus::SHIPPED;
        std::cout << "订单 " << order_id << " 已发货，状态: " << getStatusName() << std::endl;
        return true;
    }
    
    bool complete() {
        if (status != OrderStatus::SHIPPED) {
            std::cout << "错误: 只能从已发货状态完成" << std::endl;
            return false;
        }
        status = OrderStatus::COMPLETED;
        std::cout << "订单 " << order_id << " 已完成，状态: " << getStatusName() << std::endl;
        return true;
    }
    
    bool cancel() {
        if (status == OrderStatus::COMPLETED || status == OrderStatus::CANCELLED) {
            std::cout << "错误: 订单已完成或已取消，无法取消" << std::endl;
            return false;
        }
        status = OrderStatus::CANCELLED;
        std::cout << "订单 " << order_id << " 已取消，状态: " << getStatusName() << std::endl;
        return true;
    }
    
    std::string getStatusName() const {
        switch (status) {
            case OrderStatus::DRAFT: return "草稿";
            case OrderStatus::PENDING: return "待支付";
            case OrderStatus::PAID: return "已支付";
            case OrderStatus::SHIPPED: return "已发货";
            case OrderStatus::COMPLETED: return "已完成";
            case OrderStatus::CANCELLED: return "已取消";
            default: return "未知";
        }
    }
};

int main() {
    std::cout << "=== 入门级：订单状态机 ===" << std::endl;
    
    SimpleOrder order("ORD-001");
    
    // 正常流程
    order.submit();
    order.pay();
    order.ship();
    order.complete();
    
    // 测试取消功能
    std::cout << "\n--- 测试取消功能 ---" << std::endl;
    SimpleOrder order2("ORD-002");
    order2.submit();
    order2.cancel();
    
    // 测试非法操作
    std::cout << "\n--- 测试非法操作 ---" << std::endl;
    SimpleOrder order3("ORD-003");
    order3.pay();  // 应该失败
    order3.complete();  // 应该失败
    
    return 0;
}

📝 核心概念回顾

任务调度：

线程（Thread）：并发执行的基本单位
异步（Async）：不阻塞主线程的执行方式
Future：获取异步结果的机制

状态机：

状态（State）：系统当前的情况
事件（Event）：触发状态变化的原因
转换（Transition）：状态之间的变化规则

✅ 入门级掌握标准

状态机：

✅ 进阶级掌握标准

第三阶段：高阶级 🎓

一、高级任务调度技术

1.1 任务窃取（Work Stealing）

原理： 当某个线程的任务队列为空时，从其他线程的队列"窃取"任务

状态机：

✅ 高阶级掌握标准

第四阶段：专家级 🌟

一、专家级任务调度架构

1.1 基于C++20协程的调度器

✅ 专家级掌握标准

状态机：

能够创建和管理线程
理解 std::async 和 std::future 的使用
能够使用 if-else 或 switch-case 实现简单状态机
理解状态、事件、转换的基本概念

第二阶段：进阶级 🚀

一、面向对象的任务调度

1.1 线程池模式

为什么要用线程池？
避免频繁创建销毁线程的开销
控制并发数量，防止资源耗尽

提高响应速度

cpp 复制代码

#include <iostream>
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <future>

class ThreadPool {
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
    
public:
    // 构造函数：创建指定数量的工作线程
    ThreadPool(size_t threads) : stop(false) {
        for (size_t i = 0; i < threads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    
                    // 等待任务
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->condition.wait(lock, [this] {
                            return this->stop || !this->tasks.empty();
                        });
                        
                        // 如果停止且队列为空，退出线程
                        if (this->stop && this->tasks.empty()) {
                            return;
                        }
                        
                        // 取出任务
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    
                    // 执行任务
                    task();
                }
            });
        }
    }
    
    // 提交任务，返回 future 用于获取结果
    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type> {
        
        using return_type = typename std::result_of<F(Args...)>::type;
        
        // 创建 packaged_task
        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        
        std::future<return_type> res = task->get_future();
        
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            
            // 不允许在停止后提交任务
            if (stop) {
                throw std::runtime_error("提交任务到已停止的线程池");
            }
            
            // 添加任务到队列
            tasks.emplace([task]() { (*task)(); });
        }
        
        // 通知一个工作线程
        condition.notify_one();
        return res;
    }
    
    // 析构函数：停止线程池
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        
        condition.notify_all();
        
        for (std::thread &worker : workers) {
            worker.join();
        }
    }
};

// 使用示例
int main() {
    std::cout << "=== 进阶级：线程池实现 ===" << std::endl;
    
    // 创建一个4线程的线程池
    ThreadPool pool(4);
    
    // 提交一些任务
    std::vector<std::future<int>> futures;
    
    for (int i = 0; i < 10; ++i) {
        auto result = pool.enqueue([i]() -> int {
            std::cout << "任务 " << i << " 在线程 " 
                      << std::this_thread::get_id() << " 执行" << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            return i * i;
        });
        
        futures.push_back(std::move(result));
    }
    
    // 获取所有结果
    std::cout << "\n任务结果：" << std::endl;
    for (size_t i = 0; i < futures.size(); ++i) {
        std::cout << "任务 " << i << " 结果: " << futures[i].get() << std::endl;
    }
    
    return 0;
}

1.2 任务优先级调度

cpp 复制代码

#include <iostream>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <vector>
#include <chrono>

enum class TaskPriority {
    LOW = 0,
    NORMAL = 1,
    HIGH = 2,
    CRITICAL = 3
};

struct Task {
    std::function<void()> func;
    TaskPriority priority;
    size_t id;
    
    // 用于优先级队列排序（优先级高的在前）
    bool operator<(const Task& other) const {
        if (priority != other.priority) {
            return priority < other.priority;
        }
        return id > other.id;  // 先到先服务
    }
};

class PriorityTaskScheduler {
private:
    std::priority_queue<Task> task_queue;
    std::mutex queue_mutex;
    std::condition_variable condition;
    std::vector<std::thread> workers;
    bool stop;
    size_t task_counter;
    
public:
    PriorityTaskScheduler(size_t num_workers) : stop(false), task_counter(0) {
        for (size_t i = 0; i < num_workers; ++i) {
            workers.emplace_back([this, i]() {
                workerThread(i);
            });
        }
    }
    
    void submit(const std::function<void()>& func, TaskPriority priority = TaskPriority::NORMAL) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            task_queue.push({func, priority, task_counter++});
        }
        condition.notify_one();
    }
    
    void shutdown() {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        
        for (auto& worker : workers) {
            if (worker.joinable()) {
                worker.join();
            }
        }
    }
    
private:
    void workerThread(size_t worker_id) {
        while (true) {
            Task task;
            
            {
                std::unique_lock<std::mutex> lock(queue_mutex);
                condition.wait(lock, [this] {
                    return stop || !task_queue.empty();
                });
                
                if (stop && task_queue.empty()) {
                    return;
                }
                
                task = std::move(task_queue.top());
                task_queue.pop();
            }
            
            // 执行任务
            std::cout << "[Worker " << worker_id << "] 执行优先级 " 
                      << static_cast<int>(task.priority) << " 的任务" << std::endl;
            task.func();
        }
    }
};

// 使用示例
int main() {
    std::cout << "=== 进阶级：优先级任务调度 ===" << std::endl;
    
    PriorityTaskScheduler scheduler(3);
    
    // 提交不同优先级的任务
    scheduler.submit([]() {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::cout << "[LOW] 处理日志记录" << std::endl;
    }, TaskPriority::LOW);
    
    scheduler.submit([]() {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::cout << "[NORMAL] 处理普通请求" << std::endl;
    }, TaskPriority::NORMAL);
    
    scheduler.submit([]() {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::cout << "[HIGH] 处理支付请求" << std::endl;
    }, TaskPriority::HIGH);
    
    scheduler.submit([]() {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::cout << "[CRITICAL] 处理紧急报警" << std::endl;
    }, TaskPriority::CRITICAL);
    
    // 等待所有任务完成
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    scheduler.shutdown();
    std::cout << "调度器已关闭" << std::endl;
    
    return 0;
}

1.3 实战：Web服务器请求调度器

cpp 复制代码

#include <iostream>
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <memory>
#include <chrono>
#include <string>
#include <sstream>

// HTTP请求
struct HttpRequest {
    std::string method;
    std::string url;
    std::string body;
    int client_id;
};

// HTTP响应
struct HttpResponse {
    int status_code;
    std::string body;
};

// 请求处理器
class RequestHandler {
public:
    static HttpResponse handleRequest(const HttpRequest& req) {
        // 模拟处理时间
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        
        // 简单的路由逻辑
        if (req.url == "/api/login") {
            return {200, "{\"status\":\"success\",\"token\":\"abc123\"}"};
        } else if (req.url == "/api/data") {
            return {200, "{\"data\":\"some_data\"}"};
        } else if (req.url == "/api/admin") {
            return {200, "{\"admin\":\"true\"}"};
        } else {
            return {404, "{\"error\":\"Not Found\"}"};
        }
    }
};

// Web服务器
class WebServer {
private:
    std::queue<HttpRequest> request_queue;
    std::mutex queue_mutex;
    std::condition_variable condition;
    std::vector<std::thread> workers;
    bool stop;
    int worker_count;
    
    std::atomic<int> processed_requests{0};
    std::atomic<int> active_connections{0};
    
public:
    WebServer(int num_workers) : stop(false), worker_count(num_workers) {
        // 创建工作线程
        for (int i = 0; i < num_workers; ++i) {
            workers.emplace_back([this, i]() {
                workerThread(i);
            });
        }
    }
    
    // 接收请求
    void receiveRequest(const HttpRequest& request) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            request_queue.push(request);
        }
        condition.notify_one();
        
        std::cout << "[Server] 接收到请求: " << request.method << " " 
                  << request.url << " (Client: " << request.client_id << ")" << std::endl;
    }
    
    // 新连接
    void acceptConnection(int client_id) {
        active_connections++;
        std::cout << "[Server] 新连接: Client " << client_id 
                  << " (Active: " << active_connections << ")" << std::endl;
    }
    
    // 关闭连接
    void closeConnection(int client_id) {
        active_connections--;
        std::cout << "[Server] 连接关闭: Client " << client_id 
                  << " (Active: " << active_connections << ")" << std::endl;
    }
    
    // 获取统计信息
    void printStats() const {
        std::cout << "\n=== 服务器统计 ===" << std::endl;
        std::cout << "工作线程数: " << worker_count << std::endl;
        std::cout << "活跃连接: " << active_connections.load() << std::endl;
        std::cout << "已处理请求: " << processed_requests.load() << std::endl;
    }
    
    void shutdown() {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        
        for (auto& worker : workers) {
            if (worker.joinable()) {
                worker.join();
            }
        }
    }
    
private:
    void workerThread(int worker_id) {
        while (true) {
            HttpRequest request;
            
            {
                std::unique_lock<std::mutex> lock(queue_mutex);
                condition.wait(lock, [this] {
                    return stop || !request_queue.empty();
                });
                
                if (stop && request_queue.empty()) {
                    return;
                }
                
                request = std::move(request_queue.front());
                request_queue.pop();
            }
            
            // 处理请求
            auto start_time = std::chrono::high_resolution_clock::now();
            HttpResponse response = RequestHandler::handleRequest(request);
            auto end_time = std::chrono::high_resolution_clock::now();
            
            auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
            
            std::cout << "[Worker " << worker_id << "] 处理完成: " 
                      << request.url << " -> " << response.status_code 
                      << " (" << duration.count() << "μs)" << std::endl;
            
            processed_requests++;
        }
    }
};

// 模拟客户端
void simulateClient(WebServer& server, int client_id, int num_requests) {
    server.acceptConnection(client_id);
    
    for (int i = 0; i < num_requests; ++i) {
        std::vector<std::string> urls = {
            "/api/login",
            "/api/data",
            "/api/admin",
            "/api/unknown"
        };
        
        HttpRequest req{
            "GET",
            urls[i % urls.size()],
            "",
            client_id
        };
        
        server.receiveRequest(req);
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    
    server.closeConnection(client_id);
}

int main() {
    std::cout << "=== 进阶级：Web服务器请求调度器 ===" << std::endl;
    
    // 创建服务器，4个工作线程
    WebServer server(4);
    
    // 模拟10个客户端并发访问
    std::vector<std::thread> clients;
    for (int i = 0; i < 10; ++i) {
        clients.emplace_back(simulateClient, std::ref(server), i, 5);
    }
    
    // 等待所有客户端完成
    for (auto& client : clients) {
        client.join();
    }
    
    // 打印统计信息
    server.printStats();
    
    // 关闭服务器
    server.shutdown();
    
    std::cout << "\n=== 服务器关闭 ===" << std::endl;
    
    return 0;
}

二、面向对象的状态机

2.1 状态模式（State Pattern）

为什么要用状态模式？

避免庞大的 switch-case 或 if-else 语句
符合开闭原则（对扩展开放，对修改封闭）

每个状态独立，易于维护和测试

cpp 复制代码

#include <iostream>
#include <memory>
#include <string>

// 前置声明
class VendingMachine;

// 状态基类
class VendingMachineState {
public:
    virtual ~VendingMachineState() = default;
    
    // 处理投币事件
    virtual void insertCoin(VendingMachine& machine, double amount) = 0;
    
    // 处理选择商品事件
    virtual void selectItem(VendingMachine& machine, const std::string& item) = 0;
    
    // 处理退币事件
    virtual void ejectCoin(VendingMachine& machine) = 0;
    
    // 处理发放商品事件
    virtual void dispense(VendingMachine& machine) = 0;
    
    // 获取状态名称
    virtual std::string getStateName() const = 0;
};

// 售货机类
class VendingMachine {
private:
    std::unique_ptr<VendingMachineState> currentState;
    double balance;
    std::string selectedItem;
    
public:
    VendingMachine();
    
    void setState(std::unique_ptr<VendingMachineState> newState) {
        currentState = std::move(newState);
        std::cout << "=== 状态切换: " << currentState->getStateName() << " ===" << std::endl;
    }
    
    void insertCoin(double amount) {
        std::cout << "\n[事件] 投入 " << amount << " 元" << std::endl;
        currentState->insertCoin(*this, amount);
    }
    
    void selectItem(const std::string& item) {
        std::cout << "\n[事件] 选择商品: " << item << std::endl;
        currentState->selectItem(*this, item);
    }
    
    void ejectCoin() {
        std::cout << "\n[事件] 退币" << std::endl;
        currentState->ejectCoin(*this);
    }
    
    void dispense() {
        std::cout << "\n[事件] 发放商品" << std::endl;
        currentState->dispense(*this);
    }
    
    double getBalance() const { return balance; }
    void setBalance(double b) { balance = b; }
    
    const std::string& getSelectedItem() const { return selectedItem; }
    void setSelectedItem(const std::string& item) { selectedItem = item; }
    
    void printStatus() const {
        std::cout << "当前状态: " << currentState->getStateName() 
                  << ", 余额: " << balance << " 元";
        if (!selectedItem.empty()) {
            std::cout << ", 已选商品: " << selectedItem;
        }
        std::cout << std::endl;
    }
};

// 具体状态类：待机状态
class NoCoinState : public VendingMachineState {
public:
    void insertCoin(VendingMachine& machine, double amount) override {
        std::cout << "接受投币" << std::endl;
        machine.setBalance(amount);
        machine.setState(std::make_unique<HasCoinState>());
    }
    
    void selectItem(VendingMachine& machine, const std::string& item) override {
        std::cout << "错误: 请先投币" << std::endl;
    }
    
    void ejectCoin(VendingMachine& machine) override {
        std::cout << "错误: 没有硬币可退" << std::endl;
    }
    
    void dispense(VendingMachine& machine) override {
        std::cout << "错误: 请先投币和选择商品" << std::endl;
    }
    
    std::string getStateName() const override { return "待机状态（无硬币）"; }
};

// 具体状态类：已投币状态
class HasCoinState : public VendingMachineState {
public:
    void insertCoin(VendingMachine& machine, double amount) override {
        std::cout << "已投币，不能再投币" << std::endl;
    }
    
    void selectItem(VendingMachine& machine, const std::string& item) override {
        std::cout << "商品已选择: " << item << std::endl;
        machine.setSelectedItem(item);
        machine.setState(std::make_unique<SoldState>());
    }
    
    void ejectCoin(VendingMachine& machine) override {
        std::cout << "退还 " << machine.getBalance() << " 元" << std::endl;
        machine.setBalance(0);
        machine.setState(std::make_unique<NoCoinState>());
    }
    
    void dispense(VendingMachine& machine) override {
        std::cout << "错误: 请先选择商品" << std::endl;
    }
    
    std::string getStateName() const override { return "已投币状态"; }
};

// 具体状态类：已售出状态
class SoldState : public VendingMachineState {
public:
    void insertCoin(VendingMachine& machine, double amount) override {
        std::cout << "错误: 正在发放商品，请等待" << std::endl;
    }
    
    void selectItem(VendingMachine& machine, const std::string& item) override {
        std::cout << "错误: 正在发放商品，请等待" << std::endl;
    }
    
    void ejectCoin(VendingMachine& machine) override {
        std::cout << "错误: 商品已售出，无法退币" << std::endl;
    }
    
    void dispense(VendingMachine& machine) override {
        std::cout << "发放商品: " << machine.getSelectedItem() << std::endl;
        std::cout << "找零: " << machine.getBalance() - 2.0 << " 元" << std::endl;
        
        machine.setBalance(0);
        machine.setSelectedItem("");
        machine.setState(std::make_unique<NoCoinState>());
    }
    
    std::string getStateName() const override { return "已售出状态"; }
};

// 初始化售货机
VendingMachine::VendingMachine() : balance(0) {
    currentState = std::make_unique<NoCoinState>();
    std::cout << "售货机初始化完成" << std::endl;
}

// 使用示例
int main() {
    std::cout << "=== 进阶级：状态模式 - 售货机 ===" << std::endl;
    
    VendingMachine machine;
    machine.printStatus();
    
    // 正常流程
    machine.insertCoin(5.0);
    machine.printStatus();
    
    machine.selectItem("可乐");
    machine.printStatus();
    
    machine.dispense();
    machine.printStatus();
    
    // 测试退币
    std::cout << "\n--- 测试退币 ---" << std::endl;
    machine.insertCoin(3.0);
    machine.printStatus();
    
    machine.ejectCoin();
    machine.printStatus();
    
    // 测试错误操作
    std::cout << "\n--- 测试错误操作 ---" << std::endl;
    machine.selectItem("薯片");  // 未投币就选择商品
    machine.dispense();          // 未选择商品就发放
    
    return 0;
}

2.3 实战：TCP连接状态机

cpp 复制代码

#include <iostream>
#include <string>
#include <map>
#include <functional>

// TCP连接状态（简化版）
enum class TcpState {
    CLOSED,      // 已关闭
    LISTEN,      // 监听
    SYN_SENT,    // 已发送SYN
    SYN_RCVD,    // 已接收SYN
    ESTABLISHED, // 已建立
    FIN_WAIT_1,  // 等待FIN 1
    FIN_WAIT_2,  // 等待FIN 2
    CLOSING,     // 正在关闭
    TIME_WAIT,   // 等待时间
    CLOSE_WAIT,  // 等待关闭
    LAST_ACK     // 最后确认
};

// TCP事件
enum class TcpEvent {
    APP_CONNECT,    // 应用程序连接
    APP_CLOSE,      // 应用程序关闭
    APP_SEND,       // 应用程序发送
    APP_RECEIVE,    // 应用程序接收
    RCV_SYN,        // 接收SYN
    RCV_ACK,        // 接收ACK
    RCV_SYN_ACK,    // 接收SYN+ACK
    RCV_FIN,        // 接收FIN
    TIMEOUT,        // 超时
    ERROR           // 错误
};

class TcpConnection {
private:
    TcpState current_state;
    std::string connection_id;
    
    std::map<TcpState, std::map<TcpEvent, TcpState>> transition_table;
    
public:
    TcpConnection(const std::string& id) : connection_id(id), current_state(TcpState::CLOSED) {
        initializeTransitions();
        std::cout << "[" << connection_id << "] TCP连接创建，状态: " 
                  << getStateName() << std::endl;
    }
    
    bool handleEvent(TcpEvent event) {
        auto state_it = transition_table.find(current_state);
        if (state_it == transition_table.end()) {
            logError("当前状态没有定义转换");
            return false;
        }
        
        auto& event_map = state_it->second;
        auto event_it = event_map.find(event);
        if (event_it == event_map.end()) {
            logError("无效事件: " + getEventName(event));
            return false;
        }
        
        TcpState new_state = event_it->second;
        
        // 执行状态转换
        logTransition(event, new_state);
        
        // 执行转换动作
        performTransitionAction(event);
        
        current_state = new_state;
        return true;
    }
    
    TcpState getState() const { return current_state; }
    std::string getStateName() const { return getStateName(current_state); }
    
private:
    void initializeTransitions() {
        // 客户端连接流程
        transition_table[TcpState::CLOSED][TcpEvent::APP_CONNECT] = TcpState::SYN_SENT;
        transition_table[TcpState::SYN_SENT][TcpEvent::RCV_SYN_ACK] = TcpState::ESTABLISHED;
        
        // 服务器监听流程
        transition_table[TcpState::CLOSED][TcpEvent::APP_RECEIVE] = TcpState::LISTEN;
        transition_table[TcpState::LISTEN][TcpEvent::RCV_SYN] = TcpState::SYN_RCVD;
        transition_table[TcpState::SYN_RCVD][TcpEvent::RCV_ACK] = TcpState::ESTABLISHED;
        
        // 关闭流程（主动关闭）
        transition_table[TcpState::ESTABLISHED][TcpEvent::APP_CLOSE] = TcpState::FIN_WAIT_1;
        transition_table[TcpState::FIN_WAIT_1][TcpEvent::RCV_ACK] = TcpState::FIN_WAIT_2;
        transition_table[TcpState::FIN_WAIT_2][TcpEvent::RCV_FIN] = TcpState::TIME_WAIT;
        transition_table[TcpState::TIME_WAIT][TcpEvent::TIMEOUT] = TcpState::CLOSED;
        
        // 关闭流程（被动关闭）
        transition_table[TcpState::ESTABLISHED][TcpEvent::RCV_FIN] = TcpState::CLOSE_WAIT;
        transition_table[TcpState::CLOSE_WAIT][TcpEvent::APP_CLOSE] = TcpState::LAST_ACK;
        transition_table[TcpState::LAST_ACK][TcpEvent::RCV_ACK] = TcpState::CLOSED;
        
        // 错误处理
        transition_table[TcpState::SYN_SENT][TcpEvent::TIMEOUT] = TcpState::CLOSED;
        transition_table[TcpState::SYN_RCVD][TcpEvent::TIMEOUT] = TcpState::CLOSED;
    }
    
    void performTransitionAction(TcpEvent event) {
        switch (event) {
            case TcpEvent::APP_CONNECT:
                std::cout << "  [动作] 发送SYN包" << std::endl;
                break;
            case TcpEvent::RCV_SYN_ACK:
                std::cout << "  [动作] 发送ACK包，连接建立" << std::endl;
                break;
            case TcpEvent::APP_CLOSE:
                std::cout << "  [动作] 发送FIN包" << std::endl;
                break;
            case TcpEvent::RCV_FIN:
                std::cout << "  [动作] 发送ACK包" << std::endl;
                break;
            case TcpEvent::TIMEOUT:
                std::cout << "  [动作] 超时，释放资源" << std::endl;
                break;
            default:
                break;
        }
    }
    
    void logTransition(TcpEvent event, TcpState new_state) {
        std::cout << "[" << connection_id << "] " 
                  << getStateName(current_state) << " --[" 
                  << getEventName(event) << "]--> " 
                  << getStateName(new_state) << std::endl;
    }
    
    void logError(const std::string& message) {
        std::cout << "[" << connection_id << "] 错误: " << message << std::endl;
    }
    
    std::string getStateName(TcpState state) const {
        switch (state) {
            case TcpState::CLOSED: return "CLOSED";
            case TcpState::LISTEN: return "LISTEN";
            case TcpState::SYN_SENT: return "SYN_SENT";
            case TcpState::SYN_RCVD: return "SYN_RCVD";
            case TcpState::ESTABLISHED: return "ESTABLISHED";
            case TcpState::FIN_WAIT_1: return "FIN_WAIT_1";
            case TcpState::FIN_WAIT_2: return "FIN_WAIT_2";
            case TcpState::CLOSING: return "CLOSING";
            case TcpState::TIME_WAIT: return "TIME_WAIT";
            case TcpState::CLOSE_WAIT: return "CLOSE_WAIT";
            case TcpState::LAST_ACK: return "LAST_ACK";
            default: return "UNKNOWN";
        }
    }
    
    std::string getEventName(TcpEvent event) const {
        switch (event) {
            case TcpEvent::APP_CONNECT: return "APP_CONNECT";
            case TcpEvent::APP_CLOSE: return "APP_CLOSE";
            case TcpEvent::APP_SEND: return "APP_SEND";
            case TcpEvent::APP_RECEIVE: return "APP_RECEIVE";
            case TcpEvent::RCV_SYN: return "RCV_SYN";
            case TcpEvent::RCV_ACK: return "RCV_ACK";
            case TcpEvent::RCV_SYN_ACK: return "RCV_SYN_ACK";
            case TcpEvent::RCV_FIN: return "RCV_FIN";
            case TcpEvent::TIMEOUT: return "TIMEOUT";
            case TcpEvent::ERROR: return "ERROR";
            default: return "UNKNOWN";
        }
    }
};

// 使用示例
int main() {
    std::cout << "=== 进阶级：TCP连接状态机 ===" << std::endl;
    
    // 模拟客户端连接流程
    std::cout << "\n--- 客户端连接流程 ---" << std::endl;
    TcpConnection client("Client-1");
    client.handleEvent(TcpEvent::APP_CONNECT);    // CLOSED -> SYN_SENT
    client.handleEvent(TcpEvent::RCV_SYN_ACK);    // SYN_SENT -> ESTABLISHED
    
    // 模拟客户端关闭流程
    std::cout << "\n--- 客户端关闭流程 ---" << std::endl;
    client.handleEvent(TcpEvent::APP_CLOSE);      // ESTABLISHED -> FIN_WAIT_1
    client.handleEvent(TcpEvent::RCV_ACK);        // FIN_WAIT_1 -> FIN_WAIT_2
    client.handleEvent(TcpEvent::RCV_FIN);        // FIN_WAIT_2 -> TIME_WAIT
    client.handleEvent(TcpEvent::TIMEOUT);        // TIME_WAIT -> CLOSED
    
    // 模拟服务器流程
    std::cout << "\n--- 服务器流程 ---" << std::endl;
    TcpConnection server("Server-1");
    server.handleEvent(TcpEvent::APP_RECEIVE);    // CLOSED -> LISTEN
    server.handleEvent(TcpEvent::RCV_SYN);        // LISTEN -> SYN_RCVD
    server.handleEvent(TcpEvent::RCV_ACK);        // SYN_RCVD -> ESTABLISHED
    
    return 0;
}

进阶级总结

📝 核心概念回顾

任务调度：

线程池：复用线程，提高性能
优先级调度：重要任务优先执行
请求队列：缓冲和管理并发请求
状态模式：将状态封装成对象
状态转换表：集中管理转换规则
进入/退出动作：状态转换时的副作用
能够实现线程池
理解优先级调度的原理
掌握状态模式的设计思想
能够使用状态转换表管理复杂状态

能够将状态机应用到实际项目中

cpp 复制代码

#include <iostream>
#include <thread>
#include <deque>
#include <mutex>
#include <atomic>
#include <vector>
#include <functional>
#include <chrono>

template<typename T>
class WorkStealingQueue {
private:
    std::deque<T> queue;
    std::mutex mutex;
    
public:
    void push(T task) {
        std::lock_guard<std::mutex> lock(mutex);
        queue.push_front(std::move(task));
    }
    
    bool try_pop(T& task) {
        std::lock_guard<std::mutex> lock(mutex);
        if (queue.empty()) {
            return false;
        }
        task = std::move(queue.front());
        queue.pop_front();
        return true;
    }
    
    bool try_steal(T& task) {
        std::lock_guard<std::mutex> lock(mutex);
        if (queue.empty()) {
            return false;
        }
        task = std::move(queue.back());
        queue.pop_back();
        return true;
    }
};

class WorkStealingThreadPool {
private:
    std::vector<WorkStealingQueue<std::function<void()>>> local_queues;
    std::vector<std::thread> threads;
    std::atomic<bool> stop{false};
    
public:
    WorkStealingThreadPool(size_t num_threads) : local_queues(num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            threads.emplace_back([this, i]() {
                workerThread(i);
            });
        }
    }
    
    void submit(std::function<void()> task) {
        // 简单实现：使用线程ID哈希选择队列
        size_t index = std::hash<std::thread::id>{}(std::this_thread::get_id()) % local_queues.size();
        local_queues[index].push(std::move(task));
    }
    
    void shutdown() {
        stop = true;
        for (auto& thread : threads) {
            if (thread.joinable()) {
                thread.join();
            }
        }
    }
    
private:
    void workerThread(size_t thread_id) {
        while (!stop.load()) {
            std::function<void()> task;
            
            // 1. 先尝试从自己的队列获取任务
            if (local_queues[thread_id].try_pop(task)) {
                std::cout << "[Thread " << thread_id << "] 执行本地任务" << std::endl;
                task();
            } 
            // 2. 如果自己的队列为空，尝试从其他队列窃取
            else {
                bool found = false;
                for (size_t i = 0; i < local_queues.size() && !found; ++i) {
                    if (i != thread_id) {
                        if (local_queues[i].try_steal(task)) {
                            std::cout << "[Thread " << thread_id 
                                      << "] 从 Thread " << i << " 窃取任务" << std::endl;
                            found = true;
                            task();
                        }
                    }
                }
                
                // 3. 如果所有队列都为空，短暂休眠
                if (!found) {
                    std::this_thread::sleep_for(std::chrono::milliseconds(1));
                }
            }
        }
    }
};

// 使用示例
int main() {
    std::cout << "=== 高阶级：任务窃取线程池 ===" << std::endl;
    
    WorkStealingThreadPool pool(4);
    
    // 提交一些不平衡的任务
    for (int i = 0; i < 20; ++i) {
        pool.submit([i]() {
            std::cout << "[Task " << i << "] 在线程 " 
                      << std::this_thread::get_id() << " 执行" << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        });
    }
    
    // 等待所有任务完成
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    pool.shutdown();
    std::cout << "线程池已关闭" << std::endl;
    
    return 0;
}

1.2 延迟任务调度

cpp 复制代码

#include <iostream>
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <vector>
#include <memory>

class DelayedTaskScheduler {
private:
    struct ScheduledTask {
        std::function<void()> task;
        std::chrono::steady_clock::time_point execution_time;
        int id;
        
        bool operator>(const ScheduledTask& other) const {
            return execution_time > other.execution_time;
        }
    };
    
    std::priority_queue<ScheduledTask, std::vector<ScheduledTask>, std::greater<ScheduledTask>> task_queue;
    std::mutex queue_mutex;
    std::condition_variable condition;
    std::thread scheduler_thread;
    bool stop;
    int task_counter;
    
public:
    DelayedTaskScheduler() : stop(false), task_counter(0) {
        scheduler_thread = std::thread([this]() {
            schedulerLoop();
        });
    }
    
    // 安排延迟执行的任务
    void schedule(const std::function<void()>& task, std::chrono::milliseconds delay) {
        auto execution_time = std::chrono::steady_clock::now() + delay;
        
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            task_queue.push({task, execution_time, task_counter++});
        }
        
        condition.notify_one();
    }
    
    // 安排在指定时间执行的任务
    void scheduleAt(const std::function<void()>& task, std::chrono::steady_clock::time_point time) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            task_queue.push({task, time, task_counter++});
        }
        
        condition.notify_one();
    }
    
    void shutdown() {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        
        if (scheduler_thread.joinable()) {
            scheduler_thread.join();
        }
    }
    
private:
    void schedulerLoop() {
        while (!stop) {
            std::unique_lock<std::mutex> lock(queue_mutex);
            
            if (task_queue.empty()) {
                condition.wait(lock, [this] { return stop || !task_queue.empty(); });
            } else {
                auto now = std::chrono::steady_clock::now();
                auto next_time = task_queue.top().execution_time;
                
                if (now < next_time) {
                    condition.wait_until(lock, next_time, [this] { return stop; });
                }
            }
            
            if (stop) break;
            
            // 执行到期的任务
            while (!task_queue.empty()) {
                auto now = std::chrono::steady_clock::now();
                if (task_queue.top().execution_time > now) {
                    break;
                }
                
                auto task = std::move(task_queue.top());
                task_queue.pop();
                lock.unlock();
                
                task.task();
                
                lock.lock();
            }
        }
    }
};

// 使用示例
int main() {
    std::cout << "=== 高阶级：延迟任务调度器 ===" << std::endl;
    
    DelayedTaskScheduler scheduler;
    
    auto start_time = std::chrono::steady_clock::now();
    
    // 安排多个延迟任务
    scheduler.schedule([]() {
        std::cout << "1秒后执行的任务" << std::endl;
    }, std::chrono::seconds(1));
    
    scheduler.schedule([]() {
        std::cout << "3秒后执行的任务" << std::endl;
    }, std::chrono::seconds(3));
    
    scheduler.schedule([]() {
        std::cout << "2秒后执行的任务" << std::endl;
    }, std::chrono::seconds(2));
    
    scheduler.schedule([]() {
        std::cout << "5秒后执行的任务" << std::endl;
    }, std::chrono::seconds(5));
    
    // 等待所有任务完成
    std::this_thread::sleep_for(std::chrono::seconds(6));
    
    scheduler.shutdown();
    std::cout << "调度器已关闭" << std::endl;
    
    return 0;
}

1.3 分布式任务调度框架

cpp 复制代码

#include <iostream>
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <memory>
#include <string>
#include <chrono>
#include <atomic>
#include <map>

// 任务类型
enum class TaskType {
    COMPUTE,    // 计算任务
    IO,         // IO任务
    NETWORK,    // 网络任务
    DATABASE    // 数据库任务
};

// 任务优先级
enum class TaskPriority {
    LOW = 0,
    NORMAL = 1,
    HIGH = 2,
    CRITICAL = 3
};

// 任务结构
struct Task {
    int id;
    TaskType type;
    TaskPriority priority;
    std::function<void()> function;
    std::chrono::steady_clock::time_point submission_time;
    std::string description;
    
    bool operator<(const Task& other) const {
        if (priority != other.priority) {
            return priority < other.priority;
        }
        return submission_time > other.submission_time;
    }
};

// 工作节点
class WorkerNode {
private:
    int node_id;
    std::atomic<bool> active{true};
    std::thread worker_thread;
    std::priority_queue<Task> task_queue;
    std::mutex queue_mutex;
    std::condition_variable condition;
    std::atomic<int> processed_count{0};
    
public:
    WorkerNode(int id) : node_id(id) {
        worker_thread = std::thread([this]() {
            workerLoop();
        });
    }
    
    void submitTask(const Task& task) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            task_queue.push(task);
        }
        condition.notify_one();
    }
    
    void shutdown() {
        active = false;
        condition.notify_one();
        
        if (worker_thread.joinable()) {
            worker_thread.join();
        }
    }
    
    int getProcessedCount() const { return processed_count.load(); }
    int getNodeId() const { return node_id; }
    
private:
    void workerLoop() {
        while (active.load()) {
            Task task;
            
            {
                std::unique_lock<std::mutex> lock(queue_mutex);
                condition.wait(lock, [this] {
                    return !active.load() || !task_queue.empty();
                });
                
                if (!active.load() && task_queue.empty()) {
                    break;
                }
                
                if (!task_queue.empty()) {
                    task = std::move(task_queue.top());
                    task_queue.pop();
                }
            }
            
            if (task.function) {
                std::cout << "[Node " << node_id << "] 执行任务 " 
                          << task.id << ": " << task.description << std::endl;
                task.function();
                processed_count++;
            }
        }
    }
};

// 分布式任务调度器
class DistributedTaskScheduler {
private:
    std::vector<std::unique_ptr<WorkerNode>> workers;
    std::mutex scheduler_mutex;
    std::map<TaskType, int> task_type_distribution;
    int next_worker_index{0};
    
public:
    DistributedTaskScheduler(int num_workers) {
        for (int i = 0; i < num_workers; ++i) {
            workers.push_back(std::make_unique<WorkerNode>(i));
        }
        
        // 初始化任务类型分布（简单轮询）
        task_type_distribution[TaskType::COMPUTE] = 0;
        task_type_distribution[TaskType::IO] = 0;
        task_type_distribution[TaskType::NETWORK] = 0;
        task_type_distribution[TaskType::DATABASE] = 0;
    }
    
    void submitTask(const Task& task) {
        std::lock_guard<std::mutex> lock(scheduler_mutex);
        
        // 简单的负载均衡：轮询选择工作节点
        int target_node = next_worker_index % workers.size();
        next_worker_index++;
        
        std::cout << "[Scheduler] 任务 " << task.id << " (" << getTaskTypeName(task.type) 
                  << ") -> Node " << target_node << std::endl;
        
        workers[target_node]->submitTask(task);
    }
    
    void printStatistics() const {
        std::cout << "\n=== 任务调度统计 ===" << std::endl;
        for (const auto& worker : workers) {
            std::cout << "Node " << worker->getNodeId() 
                      << ": 处理 " << worker->getProcessedCount() << " 个任务" << std::endl;
        }
    }
    
    void shutdown() {
        for (auto& worker : workers) {
            worker->shutdown();
        }
    }
    
private:
    std::string getTaskTypeName(TaskType type) const {
        switch (type) {
            case TaskType::COMPUTE: return "COMPUTE";
            case TaskType::IO: return "IO";
            case TaskType::NETWORK: return "NETWORK";
            case TaskType::DATABASE: return "DATABASE";
            default: return "UNKNOWN";
        }
    }
};

// 使用示例
int main() {
    std::cout << "=== 高阶级：分布式任务调度框架 ===" << std::endl;
    
    // 创建4个工作节点的调度器
    DistributedTaskScheduler scheduler(4);
    
    // 提交各种类型的任务
    int task_id = 0;
    
    for (int i = 0; i < 20; ++i) {
        Task task;
        task.id = task_id++;
        task.submission_time = std::chrono::steady_clock::now();
        task.priority = (i % 4 == 0) ? TaskPriority::CRITICAL : TaskPriority::NORMAL;
        
        // 交替不同类型的任务
        if (i % 4 == 0) {
            task.type = TaskType::COMPUTE;
            task.description = "计算斐波那契数列";
            task.function = []() {
                // 模拟计算
                long long result = 0;
                for (int j = 0; j < 1000000; ++j) {
                    result += j;
                }
                std::this_thread::sleep_for(std::chrono::milliseconds(50));
            };
        } else if (i % 4 == 1) {
            task.type = TaskType::IO;
            task.description = "读取文件";
            task.function = []() {
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
            };
        } else if (i % 4 == 2) {
            task.type = TaskType::NETWORK;
            task.description = "发送HTTP请求";
            task.function = []() {
                std::this_thread::sleep_for(std::chrono::milliseconds(150));
            };
        } else {
            task.type = TaskType::DATABASE;
            task.description = "查询数据库";
            task.function = []() {
                std::this_thread::sleep_for(std::chrono::milliseconds(200));
            };
        }
        
        scheduler.submitTask(task);
    }
    
    // 等待所有任务完成
    std::this_thread::sleep_for(std::chrono::seconds(3));
    
    // 打印统计信息
    scheduler.printStatistics();
    
    // 关闭调度器
    scheduler.shutdown();
    
    std::cout << "\n=== 调度器已关闭 ===" << std::endl;
    
    return 0;
}

二、高级状态机技术

2.1 层次化状态机（HSM - Hierarchical State Machine）

原理： 状态可以有父子关系，子状态继承父状态的行为

cpp 复制代码

#include <iostream>
#include <memory>
#include <string>
#include <vector>

// 事件基类
class Event {
public:
    virtual ~Event() = default;
    virtual std::string getType() const = 0;
};

class ButtonPressEvent : public Event {
public:
    std::string getType() const override { return "ButtonPress"; }
};

class TimeoutEvent : public Event {
public:
    std::string getType() const override { return "Timeout"; }
};

class PowerOffEvent : public Event {
public:
    std::string getType() const override { return "PowerOff"; }
};

// 前置声明
class HsmState;
class HierarchicalStateMachine;

// 状态基类
class HsmState {
protected:
    HierarchicalStateMachine* hsm;
    HsmState* parent_state;
    
public:
    HsmState(HierarchicalStateMachine* machine, HsmState* parent = nullptr)
        : hsm(machine), parent_state(parent) {}
    
    virtual ~HsmState() = default;
    
    virtual std::string getName() const = 0;
    
    // 处理事件，返回true表示事件被处理
    virtual bool handleEvent(const Event& event) {
        return false;  // 默认不处理，让父状态处理
    }
    
    // 进入状态
    virtual void onEntry() {
        std::cout << "  [进入] " << getName() << std::endl;
    }
    
    // 离开状态
    virtual void onExit() {
        std::cout << "  [离开] " << getName() << std::endl;
    }
    
    HsmState* getParent() const { return parent_state; }
};

// 状态机
class HierarchicalStateMachine {
private:
    HsmState* current_state;
    
public:
    HierarchicalStateMachine(HsmState* initial_state) : current_state(initial_state) {
        if (current_state) {
            current_state->onEntry();
        }
    }
    
    ~HierarchicalStateMachine() {
        if (current_state) {
            current_state->onExit();
        }
    }
    
    void dispatchEvent(const Event& event) {
        std::cout << "\n[事件] " << event.getType() << std::endl;
        
        // 从当前状态开始，向上查找能处理事件的状态
        HsmState* state = current_state;
        bool handled = false;
        
        while (state && !handled) {
            handled = state->handleEvent(event);
            if (!handled) {
                state = state->getParent();
            }
        }
        
        if (!handled) {
            std::cout << "  [警告] 事件未被处理" << std::endl;
        }
    }
    
    void transitionTo(HsmState* new_state) {
        if (current_state) {
            current_state->onExit();
        }
        
        current_state = new_state;
        current_state->onEntry();
    }
    
    HsmState* getCurrentState() const { return current_state; }
};

// ==================== 具体状态实现 ====================

// 根状态：设备电源
class DevicePowerState : public HsmState {
public:
    DevicePowerState(HierarchicalStateMachine* machine) 
        : HsmState(machine, nullptr) {}
    
    std::string getName() const override { return "DevicePower"; }
    
    bool handleEvent(const Event& event) override {
        if (dynamic_cast<const PowerOffEvent*>(&event)) {
            std::cout << "  [处理] 关闭设备电源" << std::endl;
            return true;
        }
        return false;
    }
};

// 子状态：设备开启
class DeviceOnState : public HsmState {
public:
    DeviceOnState(HierarchicalStateMachine* machine, HsmState* parent) 
        : HsmState(machine, parent) {}
    
    std::string getName() const override { return "DeviceOn"; }
};

// 孙状态：待机模式
class StandbyMode : public HsmState {
public:
    StandbyMode(HierarchicalStateMachine* machine, HsmState* parent) 
        : HsmState(machine, parent) {}
    
    std::string getName() const override { return "StandbyMode"; }
    
    bool handleEvent(const Event& event) override {
        if (dynamic_cast<const ButtonPressEvent*>(&event)) {
            std::cout << "  [处理] 从待机唤醒到活动模式" << std::endl;
            hsm->transitionTo(new ActiveMode(hsm, getParent()));
            return true;
        }
        return false;
    }
};

// 孙状态：活动模式
class ActiveMode : public HsmState {
public:
    ActiveMode(HierarchicalStateMachine* machine, HsmState* parent) 
        : HsmState(machine, parent) {}
    
    std::string getName() const override { return "ActiveMode"; }
    
    bool handleEvent(const Event& event) override {
        if (dynamic_cast<const TimeoutEvent*>(&event)) {
            std::cout << "  [处理] 超时，返回待机模式" << std::endl;
            hsm->transitionTo(new StandbyMode(hsm, getParent()));
            return true;
        } else if (dynamic_cast<const ButtonPressEvent*>(&event)) {
            std::cout << "  [处理] 按钮按下，执行操作" << std::endl;
            return true;
        }
        return false;
    }
};

// 使用示例
int main() {
    std::cout << "=== 高阶级：层次化状态机（HSM） ===" << std::endl;
    std::cout << "设备状态: Power -> On -> (Standby | Active)" << std::endl;
    
    // 创建状态层次
    auto* power_state = new DevicePowerState(nullptr);
    auto* on_state = new DeviceOnState(nullptr, power_state);
    auto* standby_state = new StandbyMode(nullptr, on_state);
    
    // 创建状态机
    HierarchicalStateMachine hsm(standby_state);
    
    // 测试状态转换
    std::cout << "\n--- 测试1: 待机 -> 活动 ---" << std::endl;
    hsm.dispatchEvent(ButtonPressEvent());
    
    std::cout << "\n--- 测试2: 活动 -> 待机（超时） ---" << std::endl;
    hsm.dispatchEvent(TimeoutEvent());
    
    std::cout << "\n--- 测试3: 待机 -> 活动 -> 按钮操作 ---" << std::endl;
    hsm.dispatchEvent(ButtonPressEvent());
    hsm.dispatchEvent(ButtonPressEvent());
    
    std::cout << "\n--- 测试4: 电源关闭（根状态处理） ---" << std::endl;
    hsm.dispatchEvent(PowerOffEvent());
    
    return 0;
}

2.2 状态机持久化

cpp 复制代码

#include <iostream>
#include <string>
#include <map>
#include <fstream>
#include <sstream>
#include <memory>

// 订单状态
enum class OrderState {
    DRAFT,
    PENDING_PAYMENT,
    PAID,
    PROCESSING,
    SHIPPED,
    DELIVERED,
    COMPLETED,
    CANCELLED
};

// 订单事件
enum class OrderEvent {
    CREATE,
    SUBMIT,
    PAY,
    CANCEL,
    SHIP,
    DELIVER,
    COMPLETE
};

// 状态转换规则
class OrderStateMachine {
private:
    OrderState current_state;
    std::string order_id;
    double amount;
    std::string customer_id;
    
    std::map<OrderState, std::map<OrderEvent, OrderState>> transition_table;
    
public:
    OrderStateMachine(const std::string& id, double amt, const std::string& cust_id)
        : order_id(id), amount(amt), customer_id(cust_id), current_state(OrderState::DRAFT) {
        initializeTransitions();
    }
    
    bool handleEvent(OrderEvent event) {
        auto state_it = transition_table.find(current_state);
        if (state_it == transition_table.end()) return false;
        
        auto event_it = state_it->second.find(event);
        if (event_it == state_it->second.end()) {
            std::cout << "[Order " << order_id << "] 无效事件: " 
                      << getEventName(event) << " 在状态 " 
                      << getStateName(current_state) << std::endl;
            return false;
        }
        
        OrderState new_state = event_it->second;
        std::cout << "[Order " << order_id << "] " 
                  << getStateName(current_state) << " -> " 
                  << getStateName(new_state) << " (" 
                  << getEventName(event) << ")" << std::endl;
        
        current_state = new_state;
        return true;
    }
    
    OrderState getState() const { return current_state; }
    std::string getStateName() const { return getStateName(current_state); }
    std::string getOrderId() const { return order_id; }
    
    // 保存状态到文件
    bool saveToFile(const std::string& filename) const {
        std::ofstream file(filename);
        if (!file.is_open()) {
            std::cerr << "无法打开文件: " << filename << std::endl;
            return false;
        }
        
        file << "order_id=" << order_id << "\n";
        file << "customer_id=" << customer_id << "\n";
        file << "amount=" << amount << "\n";
        file << "state=" << static_cast<int>(current_state) << "\n";
        
        file.close();
        std::cout << "[Order " << order_id << "] 状态已保存到 " << filename << std::endl;
        return true;
    }
    
    // 从文件加载状态
    static std::unique_ptr<OrderStateMachine> loadFromFile(const std::string& filename) {
        std::ifstream file(filename);
        if (!file.is_open()) {
            std::cerr << "无法打开文件: " << filename << std::endl;
            return nullptr;
        }
        
        std::string line;
        std::string order_id, customer_id;
        double amount = 0.0;
        int state_int = 0;
        
        while (std::getline(file, line)) {
            size_t pos = line.find('=');
            if (pos == std::string::npos) continue;
            
            std::string key = line.substr(0, pos);
            std::string value = line.substr(pos + 1);
            
            if (key == "order_id") order_id = value;
            else if (key == "customer_id") customer_id = value;
            else if (key == "amount") amount = std::stod(value);
            else if (key == "state") state_int = std::stoi(value);
        }
        
        file.close();
        
        auto machine = std::make_unique<OrderStateMachine>(order_id, amount, customer_id);
        machine->current_state = static_cast<OrderState>(state_int);
        
        std::cout << "[Order " << order_id << "] 状态已从 " << filename 
                  << " 加载，当前状态: " << machine->getStateName() << std::endl;
        
        return machine;
    }
    
private:
    void initializeTransitions() {
        transition_table[OrderState::DRAFT][OrderEvent::CREATE] = OrderState::DRAFT;
        transition_table[OrderState::DRAFT][OrderEvent::SUBMIT] = OrderState::PENDING_PAYMENT;
        
        transition_table[OrderState::PENDING_PAYMENT][OrderEvent::PAY] = OrderState::PAID;
        transition_table[OrderState::PENDING_PAYMENT][OrderEvent::CANCEL] = OrderState::CANCELLED;
        
        transition_table[OrderState::PAID][OrderEvent::CANCEL] = OrderState::CANCELLED;
        transition_table[OrderState::PAID][OrderEvent::SHIP] = OrderState::PROCESSING;
        
        transition_table[OrderState::PROCESSING][OrderEvent::SHIP] = OrderState::SHIPPED;
        
        transition_table[OrderState::SHIPPED][OrderEvent::DELIVER] = OrderState::DELIVERED;
        
        transition_table[OrderState::DELIVERED][OrderEvent::COMPLETE] = OrderState::COMPLETED;
        transition_table[OrderState::DELIVERED][OrderEvent::CANCEL] = OrderState::CANCELLED;
    }
    
    std::string getStateName(OrderState state) const {
        switch (state) {
            case OrderState::DRAFT: return "DRAFT";
            case OrderState::PENDING_PAYMENT: return "PENDING_PAYMENT";
            case OrderState::PAID: return "PAID";
            case OrderState::PROCESSING: return "PROCESSING";
            case OrderState::SHIPPED: return "SHIPPED";
            case OrderState::DELIVERED: return "DELIVERED";
            case OrderState::COMPLETED: return "COMPLETED";
            case OrderState::CANCELLED: return "CANCELLED";
            default: return "UNKNOWN";
        }
    }
    
    std::string getEventName(OrderEvent event) const {
        switch (event) {
            case OrderEvent::CREATE: return "CREATE";
            case OrderEvent::SUBMIT: return "SUBMIT";
            case OrderEvent::PAY: return "PAY";
            case OrderEvent::CANCEL: return "CANCEL";
            case OrderEvent::SHIP: return "SHIP";
            case OrderEvent::DELIVER: return "DELIVER";
            case OrderEvent::COMPLETE: return "COMPLETE";
            default: return "UNKNOWN";
        }
    }
};

// 使用示例
int main() {
    std::cout << "=== 高阶级：状态机持久化 ===" << std::endl;
    
    // 创建订单并处理
    std::cout << "\n--- 创建新订单 ---" << std::endl;
    auto order = std::make_unique<OrderStateMachine>("ORD-001", 99.99, "CUST-123");
    order->handleEvent(OrderEvent::SUBMIT);
    order->handleEvent(OrderEvent::PAY);
    order->handleEvent(OrderEvent::SHIP);
    
    // 保存状态
    order->saveToFile("order_state.txt");
    
    // 模拟系统重启
    std::cout << "\n--- 系统重启，加载订单状态 ---" << std::endl;
    order = OrderStateMachine::loadFromFile("order_state.txt");
    
    // 继续处理订单
    std::cout << "\n--- 继续处理订单 ---" << std::endl;
    order->handleEvent(OrderEvent::DELIVER);
    order->handleEvent(OrderEvent::COMPLETE);
    
    return 0;
}

2.3 状态机监控与日志

cpp 复制代码

#include <iostream>
#include <string>
#include <vector>
#include <chrono>
#include <iomanip>
#include <sstream>

// 状态历史记录
struct StateTransition {
    std::string from_state;
    std::string to_state;
    std::string event;
    std::chrono::steady_clock::time_point timestamp;
    std::string notes;
};

class StateMachineMonitor {
private:
    std::vector<StateTransition> history;
    std::string machine_name;
    std::chrono::steady_clock::time_point start_time;
    
public:
    StateMachineMonitor(const std::string& name) 
        : machine_name(name), start_time(std::chrono::steady_clock::now()) {}
    
    void recordTransition(const std::string& from, const std::string& to, 
                         const std::string& event, const std::string& notes = "") {
        StateTransition record;
        record.from_state = from;
        record.to_state = to;
        record.event = event;
        record.timestamp = std::chrono::steady_clock::now();
        record.notes = notes;
        
        history.push_back(record);
        printTransition(record);
    }
    
    void printHistory() const {
        std::cout << "\n=== " << machine_name << " 状态转换历史 ===" << std::endl;
        std::cout << std::left << std::setw(12) << "时间" 
                  << std::setw(20) << "从状态" 
                  << std::setw(20) << "到状态" 
                  << std::setw(15) << "事件" 
                  << "备注" << std::endl;
        std::cout << std::string(80, '-') << std::endl;
        
        for (const auto& record : history) {
            auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
                record.timestamp - start_time
            );
            
            std::cout << std::left << std::setw(12) << (duration.count() / 1000.0) 
                      << std::setw(20) << record.from_state 
                      << std::setw(20) << record.to_state 
                      << std::setw(15) << record.event 
                      << record.notes << std::endl;
        }
    }
    
    void printStatistics() const {
        std::cout << "\n=== " << machine_name << " 统计信息 ===" << std::endl;
        std::cout << "总转换次数: " << history.size() << std::endl;
        
        if (!history.empty()) {
            auto total_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
                history.back().timestamp - start_time
            );
            std::cout << "运行时间: " << total_duration.count() / 1000.0 << " 秒" << std::endl;
            std::cout << "平均转换间隔: " << (total_duration.count() / history.size()) << " ms" << std::endl;
        }
    }
    
private:
    void printTransition(const StateTransition& record) const {
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
            record.timestamp - start_time
        );
        
        std::cout << "[" << machine_name << "] " 
                  << record.from_state << " --[" << record.event << "]--> " 
                  << record.to_state;
        if (!record.notes.empty()) {
            std::cout << " (" << record.notes << ")";
        }
        std::cout << std::endl;
    }
};

// 增强版状态机（带监控）
class MonitoredStateMachine {
private:
    std::string current_state;
    StateMachineMonitor monitor;
    
    std::map<std::string, std::map<std::string, std::string>> transitions;
    
public:
    MonitoredStateMachine(const std::string& name, const std::string& initial_state)
        : current_state(initial_state), monitor(name) {
        monitor.recordTransition("INIT", initial_state, "INITIALIZE", "状态机初始化");
    }
    
    void addTransition(const std::string& from, const std::string& event, 
                      const std::string& to, const std::string& notes = "") {
        transitions[from][event] = to;
    }
    
    bool handleEvent(const std::string& event, const std::string& notes = "") {
        auto it = transitions.find(current_state);
        if (it == transitions.end()) {
            std::cout << "[Error] 当前状态 " << current_state << " 没有定义转换" << std::endl;
            return false;
        }
        
        auto event_it = it->second.find(event);
        if (event_it == it->second.end()) {
            std::cout << "[Error] 状态 " << current_state << " 不支持事件 " << event << std::endl;
            return false;
        }
        
        std::string new_state = event_it->second;
        monitor.recordTransition(current_state, new_state, event, notes);
        current_state = new_state;
        
        return true;
    }
    
    std::string getCurrentState() const { return current_state; }
    
    void printHistory() const { monitor.printHistory(); }
    void printStatistics() const { monitor.printStatistics(); }
};

// 使用示例
int main() {
    std::cout << "=== 高阶级：状态机监控与日志 ===" << std::endl;
    
    // 创建带监控的状态机
    MonitoredStateMachine fsm("订单处理", "DRAFT");
    
    // 定义状态转换
    fsm.addTransition("DRAFT", "SUBMIT", "PENDING_PAYMENT");
    fsm.addTransition("PENDING_PAYMENT", "PAY", "PAID");
    fsm.addTransition("PAID", "SHIP", "SHIPPED");
    fsm.addTransition("SHIPPED", "DELIVER", "DELIVERED");
    fsm.addTransition("DELIVERED", "COMPLETE", "COMPLETED");
    fsm.addTransition("PENDING_PAYMENT", "CANCEL", "CANCELLED");
    fsm.addTransition("PAID", "CANCEL", "CANCELLED");
    
    // 模拟订单处理流程
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    fsm.handleEvent("SUBMIT", "用户提交订单");
    
    std::this_thread::sleep_for(std::chrono::milliseconds(200));
    fsm.handleEvent("PAY", "支付成功");
    
    std::this_thread::sleep_for(std::chrono::milliseconds(150));
    fsm.handleEvent("SHIP", "仓库发货");
    
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    fsm.handleEvent("DELIVER", "快递送达");
    
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    fsm.handleEvent("COMPLETE", "用户确认收货");
    
    // 打印历史和统计
    fsm.printHistory();
    fsm.printStatistics();
    
    return 0;
}

高阶级总结

📝 核心概念回顾

任务调度：

任务窃取：动态负载均衡
延迟调度：定时任务管理
分布式调度：多节点协同
层次化状态机：状态继承和复用
状态持久化：状态保存和恢复
状态监控：历史记录和统计分析
理解任务窃取的原理和实现
能够实现延迟任务调度器
掌握层次化状态机的设计模式
能够实现状态机的持久化

能够为状态机添加监控功能

cpp 复制代码

#include <iostream>
#include <coroutine>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <chrono>
#include <vector>
#include <memory>

// 协程Promise类型
struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

// 协程调度器
class CoroutineScheduler {
private:
    struct TaskInfo {
        std::coroutine_handle<> handle;
        std::chrono::steady_clock::time_point resume_time;
        
        bool operator>(const TaskInfo& other) const {
            return resume_time > other.resume_time;
        }
    };
    
    std::priority_queue<TaskInfo, std::vector<TaskInfo>, std::greater<TaskInfo>> task_queue;
    std::mutex queue_mutex;
    std::condition_variable condition;
    std::vector<std::thread> workers;
    std::atomic<bool> running{false};
    int worker_count;
    
public:
    CoroutineScheduler(int num_workers) : worker_count(num_workers), running(false) {}
    
    void start() {
        running = true;
        for (int i = 0; i < worker_count; ++i) {
            workers.emplace_back([this, i]() {
                workerThread(i);
            });
        }
    }
    
    void submit(std::coroutine_handle<> handle, 
                std::chrono::milliseconds delay = std::chrono::milliseconds(0)) {
        auto resume_time = std::chrono::steady_clock::now() + delay;
        
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            task_queue.push({handle, resume_time});
        }
        condition.notify_one();
    }
    
    void shutdown() {
        running = false;
        condition.notify_all();
        
        for (auto& worker : workers) {
            if (worker.joinable()) {
                worker.join();
            }
        }
    }
    
private:
    void workerThread(int worker_id) {
        while (running.load()) {
            TaskInfo task;
            
            {
                std::unique_lock<std::mutex> lock(queue_mutex);
                if (task_queue.empty()) {
                    condition.wait(lock, [this] { return !running.load() || !task_queue.empty(); });
                }
                
                if (!running.load() && task_queue.empty()) {
                    break;
                }
                
                if (!task_queue.empty()) {
                    auto now = std::chrono::steady_clock::now();
                    if (task_queue.top().resume_time <= now) {
                        task = std::move(task_queue.top());
                        task_queue.pop();
                    } else {
                        auto wait_time = task_queue.top().resume_time - now;
                        condition.wait_for(lock, wait_time, [this] { return !running.load(); });
                        continue;
                    }
                }
            }
            
            if (task.handle) {
                std::cout << "[Coroutine Worker " << worker_id << "] 执行协程" << std::endl;
                task.handle.resume();
            }
        }
    }
};

// 协程示例：异步任务
Task asyncTask(int id) {
    std::cout << "[Coroutine " << id << "] 开始执行" << std::endl;
    co_await std::suspend_always{};
    std::cout << "[Coroutine " << id << "] 恢复执行" << std::endl;
    co_await std::suspend_always{};
    std::cout << "[Coroutine " << id << "] 完成" << std::endl;
}

// 使用示例
int main() {
    std::cout << "=== 专家级：C++20协程调度器 ===" << std::endl;
    
    CoroutineScheduler scheduler(2);
    scheduler.start();
    
    // 创建几个协程
    auto handle1 = asyncTask(1).promise_type::get_return_object();
    auto handle2 = asyncTask(2).promise_type::get_return_object();
    auto handle3 = asyncTask(3).promise_type::get_return_object();
    
    // 提交协程到调度器
    scheduler.submit(handle1);
    scheduler.submit(handle2, std::chrono::milliseconds(100));
    scheduler.submit(handle3, std::chrono::milliseconds(200));
    
    // 等待所有协程完成
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    scheduler.shutdown();
    std::cout << "协程调度器已关闭" << std::endl;
    
    return 0;
}

1.2 无锁任务队列

cpp 复制代码

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>
#include <functional>
#include <chrono>
#include <memory>

// 无锁单生产者单消费者队列
template<typename T>
class LockFreeSPSCQueue {
private:
    struct Node {
        T data;
        std::atomic<Node*> next;
        
        Node(T val) : data(std::move(val)), next(nullptr) {}
    };
    
    alignas(64) std::atomic<Node*> head;
    alignas(64) std::atomic<Node*> tail;
    alignas(64) Node* dummy;
    
public:
    LockFreeSPSCQueue() {
        dummy = new Node(T{});
        head.store(dummy, std::memory_order_relaxed);
        tail.store(dummy, std::memory_order_relaxed);
    }
    
    ~LockFreeSPSCQueue() {
        while (head.load(std::memory_order_relaxed) != nullptr) {
            auto old_head = head.load(std::memory_order_relaxed);
            head.store(old_head->next.load(std::memory_order_relaxed), std::memory_order_relaxed);
            delete old_head;
        }
    }
    
    void push(T value) {
        auto new_node = new Node(std::move(value));
        auto old_tail = tail.load(std::memory_order_relaxed);
        old_tail->next.store(new_node, std::memory_order_release);
        tail.store(new_node, std::memory_order_release);
    }
    
    bool try_pop(T& value) {
        auto old_head = head.load(std::memory_order_relaxed);
        auto next = old_head->next.load(std::memory_order_acquire);
        
        if (next == nullptr) {
            return false;
        }
        
        value = std::move(next->data);
        head.store(next, std::memory_order_release);
        delete old_head;
        
        return true;
    }
    
    bool empty() const {
        return head.load(std::memory_order_acquire)->next.load(std::memory_order_acquire) == nullptr;
    }
};

// 无锁线程池
class LockFreeThreadPool {
private:
    LockFreeSPSCQueue<std::function<void()>> task_queue;
    std::vector<std::thread> workers;
    std::atomic<bool> stop{false};
    
public:
    LockFreeThreadPool(size_t num_workers) {
        for (size_t i = 0; i < num_workers; ++i) {
            workers.emplace_back([this]() {
                workerThread();
            });
        }
    }
    
    void submit(std::function<void()> task) {
        task_queue.push(std::move(task));
    }
    
    void shutdown() {
        stop = true;
        
        // 提交空任务唤醒所有线程
        for (size_t i = 0; i < workers.size(); ++i) {
            task_queue.push([]() {});
        }
        
        for (auto& worker : workers) {
            if (worker.joinable()) {
                worker.join();
            }
        }
    }
    
private:
    void workerThread() {
        while (!stop.load(std::memory_order_acquire)) {
            std::function<void()> task;
            
            if (task_queue.try_pop(task)) {
                if (task) {
                    task();
                }
            } else {
                std::this_thread::sleep_for(std::chrono::microseconds(10));
            }
        }
    }
};

// 使用示例
int main() {
    std::cout << "=== 专家级：无锁任务队列 ===" << std::endl;
    
    LockFreeThreadPool pool(4);
    
    // 提交大量任务测试性能
    const int num_tasks = 10000;
    std::atomic<int> completed{0};
    
    auto start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < num_tasks; ++i) {
        pool.submit([i, &completed]() {
            // 模拟工作
            std::this_thread::sleep_for(std::chrono::microseconds(10));
            completed.fetch_add(1, std::memory_order_relaxed);
        });
    }
    
    // 等待所有任务完成
    while (completed.load(std::memory_order_relaxed) < num_tasks) {
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    
    std::cout << "完成 " << num_tasks << " 个任务，耗时: " 
              << duration.count() << " ms" << std::endl;
    std::cout << "平均每个任务: " << (duration.count() * 1000.0 / num_tasks) << " μs" << std::endl;
    
    pool.shutdown();
    
    return 0;
}

1.3 自适应负载均衡调度器

cpp 复制代码

#include <iostream>
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <atomic>
#include <chrono>
#include <cmath>
#include <algorithm>

class AdaptiveLoadBalancer {
private:
    struct WorkerStats {
        int id;
        std::atomic<int> queue_size{0};
        std::atomic<int> processed_count{0};
        std::atomic<double> avg_processing_time{0.0};
        std::chrono::steady_clock::time_point last_update;
    };
    
    struct Task {
        std::function<void()> func;
        int priority;
        std::chrono::steady_clock::time_point submission_time;
        
        bool operator<(const Task& other) const {
            if (priority != other.priority) {
                return priority < other.priority;
            }
            return submission_time > other.submission_time;
        }
    };
    
    std::vector<std::thread> workers;
    std::vector<WorkerStats> worker_stats;
    std::vector<std::priority_queue<Task>> task_queues;
    
    std::mutex global_mutex;
    std::condition_variable condition;
    std::atomic<bool> running{false};
    std::atomic<int> total_processed{0};
    
public:
    AdaptiveLoadBalancer(int num_workers) : worker_stats(num_workers), task_queues(num_workers) {
        for (int i = 0; i < num_workers; ++i) {
            worker_stats[i].id = i;
            worker_stats[i].last_update = std::chrono::steady_clock::now();
        }
    }
    
    void start() {
        running = true;
        for (size_t i = 0; i < worker_stats.size(); ++i) {
            workers.emplace_back([this, i]() {
                workerThread(i);
            });
        }
    }
    
    void submit(std::function<void()> task, int priority = 0) {
        auto best_worker = selectBestWorker();
        
        {
            std::lock_guard<std::mutex> lock(global_mutex);
            task_queues[best_worker].push({
                std::move(task), 
                priority, 
                std::chrono::steady_clock::now()
            });
            worker_stats[best_worker].queue_size.fetch_add(1, std::memory_order_relaxed);
        }
        
        condition.notify_one();
    }
    
    void shutdown() {
        running = false;
        condition.notify_all();
        
        for (auto& worker : workers) {
            if (worker.joinable()) {
                worker.join();
            }
        }
    }
    
    void printStats() const {
        std::cout << "\n=== 负载均衡统计 ===" << std::endl;
        for (const auto& stats : worker_stats) {
            std::cout << "Worker " << stats.id << ": "
                      << "队列=" << stats.queue_size.load() << ", "
                      << "处理=" << stats.processed_count.load() << ", "
                      << "平均时间=" << stats.avg_processing_time.load() << "ms"
                      << std::endl;
        }
        
        int total = total_processed.load();
        std::cout << "总计处理: " << total << " 个任务" << std::endl;
    }
    
private:
    int selectBestWorker() {
        // 基于多个指标选择最佳工作线程
        int best_worker = 0;
        double best_score = std::numeric_limits<double>::max();
        
        for (size_t i = 0; i < worker_stats.size(); ++i) {
            auto& stats = worker_stats[i];
            
            // 计算负载分数（越低越好）
            double queue_factor = stats.queue_size.load(std::memory_order_relaxed);
            double time_factor = stats.avg_processing_time.load(std::memory_order_relaxed) / 100.0;
            
            double score = queue_factor + time_factor;
            
            if (score < best_score) {
                best_score = score;
                best_worker = i;
            }
        }
        
        return best_worker;
    }
    
    void workerThread(int worker_id) {
        auto& stats = worker_stats[worker_id];
        
        while (running.load(std::memory_order_acquire)) {
            Task task;
            
            {
                std::unique_lock<std::mutex> lock(global_mutex);
                condition.wait(lock, [this, worker_id] {
                    return !running.load(std::memory_order_acquire) || 
                           !task_queues[worker_id].empty();
                });
                
                if (!running.load(std::memory_order_acquire) && task_queues[worker_id].empty()) {
                    break;
                }
                
                if (!task_queues[worker_id].empty()) {
                    task = std::move(task_queues[worker_id].top());
                    task_queues[worker_id].pop();
                    stats.queue_size.fetch_sub(1, std::memory_order_relaxed);
                }
            }
            
            if (task.func) {
                auto start = std::chrono::high_resolution_clock::now();
                task.func();
                auto end = std::chrono::high_resolution_clock::now();
                
                auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
                
                // 更新统计数据（指数移动平均）
                double alpha = 0.1;  // 平滑因子
                double current_avg = stats.avg_processing_time.load(std::memory_order_relaxed);
                double new_avg = alpha * (duration.count() / 1000.0) + (1 - alpha) * current_avg;
                stats.avg_processing_time.store(new_avg, std::memory_order_relaxed);
                
                stats.processed_count.fetch_add(1, std::memory_order_relaxed);
                total_processed.fetch_add(1, std::memory_order_relaxed);
            }
        }
    }
};

// 使用示例
int main() {
    std::cout << "=== 专家级：自适应负载均衡调度器 ===" << std::endl;
    
    AdaptiveLoadBalancer balancer(4);
    balancer.start();
    
    // 提交不同优先级和处理时间的任务
    for (int i = 0; i < 50; ++i) {
        int priority = (i % 10 == 0) ? 10 : (i % 3);  // 偶尔有高优先级任务
        
        balancer.submit([i, priority]() {
            // 模拟不同处理时间
            int sleep_ms = (priority > 5) ? 50 : (20 + (i % 30));
            std::this_thread::sleep_for(std::chrono::milliseconds(sleep_ms));
        }, priority);
    }
    
    // 等待所有任务完成
    std::this_thread::sleep_for(std::chrono::seconds(3));
    
    balancer.printStats();
    balancer.shutdown();
    
    std::cout << "\n=== 调度器已关闭 ===" << std::endl;
    
    return 0;
}

二、专家级状态机架构

2.1 基于事件溯源的状态机

cpp 复制代码

#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <functional>
#include <map>
#include <chrono>
#include <fstream>
#include <sstream>

// 事件基类
class DomainEvent {
public:
    virtual ~DomainEvent() = default;
    virtual std::string getType() const = 0;
    virtual std::string serialize() const = 0;
    virtual void deserialize(const std::string& data) = 0;
};

// 具体事件
class OrderCreatedEvent : public DomainEvent {
public:
    std::string order_id;
    std::string customer_id;
    double amount;
    
    std::string getType() const override { return "OrderCreated"; }
    
    std::string serialize() const override {
        return order_id + "|" + customer_id + "|" + std::to_string(amount);
    }
    
    void deserialize(const std::string& data) override {
        std::istringstream iss(data);
        std::string token;
        std::getline(iss, order_id, '|');
        std::getline(iss, customer_id, '|');
        std::getline(iss, token, '|');
        amount = std::stod(token);
    }
};

class OrderPaidEvent : public DomainEvent {
public:
    std::string order_id;
    std::string payment_method;
    
    std::string getType() const override { return "OrderPaid"; }
    
    std::string serialize() const override {
        return order_id + "|" + payment_method;
    }
    
    void deserialize(const std::string& data) override {
        std::istringstream iss(data);
        std::getline(iss, order_id, '|');
        std::getline(iss, payment_method, '|');
    }
};

class OrderShippedEvent : public DomainEvent {
public:
    std::string order_id;
    std::string tracking_number;
    
    std::string getType() const override { return "OrderShipped"; }
    
    std::string serialize() const override {
        return order_id + "|" + tracking_number;
    }
    
    void deserialize(const std::string& data) override {
        std::istringstream iss(data);
        std::getline(iss, order_id, '|');
        std::getline(iss, tracking_number, '|');
    }
};

// 事件存储
class EventStore {
private:
    std::map<std::string, std::vector<std::shared_ptr<DomainEvent>>> events;
    std::map<std::string, std::function<std::shared_ptr<DomainEvent>(const std::string&)>> event_factories;
    
public:
    EventStore() {
        // 注册事件工厂
        event_factories["OrderCreated"] = [](const std::string& data) {
            auto event = std::make_shared<OrderCreatedEvent>();
            event->deserialize(data);
            return event;
        };
        
        event_factories["OrderPaid"] = [](const std::string& data) {
            auto event = std::make_shared<OrderPaidEvent>();
            event->deserialize(data);
            return event;
        };
        
        event_factories["OrderShipped"] = [](const std::string& data) {
            auto event = std::make_shared<OrderShippedEvent>();
            event->deserialize(data);
            return event;
        };
    }
    
    void appendEvent(const std::string& aggregate_id, const std::shared_ptr<DomainEvent>& event) {
        events[aggregate_id].push_back(event);
        std::cout << "[EventStore] 保存事件: " << event->getType() 
                  << " for " << aggregate_id << std::endl;
    }
    
    std::vector<std::shared_ptr<DomainEvent>> getEvents(const std::string& aggregate_id) const {
        auto it = events.find(aggregate_id);
        if (it != events.end()) {
            return it->second;
        }
        return {};
    }
    
    bool saveToFile(const std::string& filename) const {
        std::ofstream file(filename);
        if (!file.is_open()) return false;
        
        for (const auto& [aggregate_id, event_list] : events) {
            for (const auto& event : event_list) {
                file << aggregate_id << "|" << event->getType() << "|" << event->serialize() << "\n";
            }
        }
        
        file.close();
        return true;
    }
    
    bool loadFromFile(const std::string& filename) {
        std::ifstream file(filename);
        if (!file.is_open()) return false;
        
        std::string line;
        while (std::getline(file, line)) {
            std::istringstream iss(line);
            std::string aggregate_id, event_type, event_data;
            
            std::getline(iss, aggregate_id, '|');
            std::getline(iss, event_type, '|');
            std::getline(iss, event_data, '\n');
            
            auto factory_it = event_factories.find(event_type);
            if (factory_it != event_factories.end()) {
                auto event = factory_it->second(event_data);
                events[aggregate_id].push_back(event);
            }
        }
        
        file.close();
        return true;
    }
};

// 基于事件溯源的聚合根
class EventSourcedAggregate {
protected:
    std::string id;
    EventStore& event_store;
    std::vector<std::shared_ptr<DomainEvent>> uncommitted_events;
    
public:
    EventSourcedAggregate(const std::string& aggregate_id, EventStore& store)
        : id(aggregate_id), event_store(store) {}
    
    virtual ~EventSourcedAggregate() = default;
    
    // 应用事件（用于重放）
    virtual void apply(const std::shared_ptr<DomainEvent>& event) = 0;
    
    // 重放所有事件以恢复状态
    void replayEvents() {
        auto events = event_store.getEvents(id);
        for (const auto& event : events) {
            apply(event);
        }
    }
    
    // 提交未提交的事件
    void commitEvents() {
        for (const auto& event : uncommitted_events) {
            event_store.appendEvent(id, event);
        }
        uncommitted_events.clear();
    }
    
    std::string getId() const { return id; }
};

// 订单聚合根
class OrderAggregate : public EventSourcedAggregate {
private:
    std::string customer_id;
    double amount;
    std::string status;  // "DRAFT", "PAID", "SHIPPED", "COMPLETED"
    std::string payment_method;
    std::string tracking_number;
    
public:
    OrderAggregate(const std::string& order_id, EventStore& store)
        : EventSourcedAggregate(order_id, store), status("DRAFT") {
        // 重放事件以恢复状态
        replayEvents();
    }
    
    void apply(const std::shared_ptr<DomainEvent>& event) override {
        if (auto created = std::dynamic_pointer_cast<OrderCreatedEvent>(event)) {
            customer_id = created->customer_id;
            amount = created->amount;
            status = "DRAFT";
        } else if (auto paid = std::dynamic_pointer_cast<OrderPaidEvent>(event)) {
            payment_method = paid->payment_method;
            status = "PAID";
        } else if (auto shipped = std::dynamic_pointer_cast<OrderShippedEvent>(event)) {
            tracking_number = shipped->tracking_number;
            status = "SHIPPED";
        }
    }
    
    void createOrder(const std::string& cust_id, double amt) {
        if (status != "DRAFT") {
            throw std::runtime_error("订单已存在");
        }
        
        auto event = std::make_shared<OrderCreatedEvent>();
        event->order_id = id;
        event->customer_id = cust_id;
        event->amount = amt;
        
        apply(event);
        uncommitted_events.push_back(event);
    }
    
    void payOrder(const std::string& method) {
        if (status != "DRAFT") {
            throw std::runtime_error("订单必须是草稿状态才能支付");
        }
        
        auto event = std::make_shared<OrderPaidEvent>();
        event->order_id = id;
        event->payment_method = method;
        
        apply(event);
        uncommitted_events.push_back(event);
    }
    
    void shipOrder(const std::string& tracking) {
        if (status != "PAID") {
            throw std::runtime_error("订单必须已支付才能发货");
        }
        
        auto event = std::make_shared<OrderShippedEvent>();
        event->order_id = id;
        event->tracking_number = tracking;
        
        apply(event);
        uncommitted_events.push_back(event);
    }
    
    void commit() {
        commitEvents();
    }
    
    std::string getStatus() const { return status; }
    double getAmount() const { return amount; }
    std::string getCustomerId() const { return customer_id; }
};

// 使用示例
int main() {
    std::cout << "=== 专家级：基于事件溯源的状态机 ===" << std::endl;
    
    EventStore event_store;
    
    // 创建新订单
    {
        OrderAggregate order("ORD-001", event_store);
        order.createOrder("CUST-123", 99.99);
        order.payOrder("CreditCard");
        order.commit();
        
        std::cout << "订单 " << order.getId() << " 状态: " << order.getStatus() << std::endl;
    }
    
    // 从事件重放恢复订单
    {
        OrderAggregate order("ORD-001", event_store);
        std::cout << "重放后订单状态: " << order.getStatus() << std::endl;
        std::cout << "订单金额: " << order.getAmount() << std::endl;
    }
    
    // 继续处理订单
    {
        OrderAggregate order("ORD-001", event_store);
        order.shipOrder("TRACK-123456");
        order.commit();
        
        std::cout << "发货后订单状态: " << order.getStatus() << std::endl;
    }
    
    // 保存事件到文件
    event_store.saveToFile("events.log");
    std::cout << "\n事件已保存到 events.log" << std::endl;
    
    // 从文件加载事件
    EventStore new_store;
    new_store.loadFromFile("events.log");
    
    OrderAggregate restored_order("ORD-001", new_store);
    std::cout << "\n从文件恢复订单状态: " << restored_order.getStatus() << std::endl;
    
    return 0;
}

2.2 分布式状态机（Raft算法简化版）

cpp 复制代码

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <thread>
#include <mutex>
#include <atomic>
#include <chrono>
#include <random>
#include <queue>
#include <functional>

enum class NodeState {
    FOLLOWER,
    CANDIDATE,
    LEADER
};

struct LogEntry {
    int term;
    std::string command;
    int index;
};

class RaftNode {
private:
    int node_id;
    std::atomic<NodeState> state{NodeState::FOLLOWER};
    std::atomic<int> current_term{0};
    std::atomic<int> voted_for{-1};
    std::vector<LogEntry> log;
    
    std::atomic<int> commit_index{0};
    std::atomic<int> last_applied{0};
    
    std::map<int, int> next_index;      // 对每个节点的下一个日志索引
    std::map<int, int> match_index;     // 对每个节点已匹配的日志索引
    
    std::atomic<int> voted_count{0};
    std::atomic<bool> running{true};
    
    std::mutex mutex;
    std::thread election_thread;
    std::thread heartbeat_thread;
    
    std::random_device rd;
    std::mt19937 gen;
    std::uniform_int_distribution<> election_timeout_dist;
    
public:
    RaftNode(int id, const std::vector<int>& peer_ids)
        : node_id(id), gen(rd()), election_timeout_dist(150, 300) {
        
        for (int peer_id : peer_ids) {
            next_index[peer_id] = 0;
            match_index[peer_id] = 0;
        }
    }
    
    void start() {
        election_thread = std::thread([this]() { electionLoop(); });
        heartbeat_thread = std::thread([this]() { heartbeatLoop(); });
    }
    
    void stop() {
        running = false;
        if (election_thread.joinable()) election_thread.join();
        if (heartbeat_thread.joinable()) heartbeat_thread.join();
    }
    
    bool appendCommand(const std::string& command) {
        std::lock_guard<std::mutex> lock(mutex);
        
        if (state.load() != NodeState::LEADER) {
            std::cout << "[Node " << node_id << "] 不是Leader，无法追加命令" << std::endl;
            return false;
        }
        
        LogEntry entry;
        entry.term = current_term.load();
        entry.command = command;
        entry.index = log.size();
        
        log.push_back(entry);
        std::cout << "[Node " << node_id << "] 追加日志: " << command << std::endl;
        
        return true;
    }
    
    std::string getStateName() const {
        switch (state.load()) {
            case NodeState::FOLLOWER: return "FOLLOWER";
            case NodeState::CANDIDATE: return "CANDIDATE";
            case NodeState::LEADER: return "LEADER";
            default: return "UNKNOWN";
        }
    }
    
private:
    void electionLoop() {
        while (running.load()) {
            if (state.load() == NodeState::FOLLOWER) {
                auto timeout = std::chrono::milliseconds(election_timeout_dist(gen));
                std::this_thread::sleep_for(timeout);
                
                // 超时，开始选举
                std::lock_guard<std::mutex> lock(mutex);
                if (state.load() == NodeState::FOLLOWER) {
                    becomeCandidate();
                }
            } else {
                std::this_thread::sleep_for(std::chrono::milliseconds(50));
            }
        }
    }
    
    void heartbeatLoop() {
        while (running.load()) {
            if (state.load() == NodeState::LEADER) {
                sendHeartbeats();
                std::this_thread::sleep_for(std::chrono::milliseconds(50));
            } else {
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
            }
        }
    }
    
    void becomeCandidate() {
        current_term.fetch_add(1);
        state.store(NodeState::CANDIDATE);
        voted_for.store(node_id);
        voted_count.store(1);
        
        std::cout << "[Node " << node_id << "] 成为候选人，任期: " 
                  << current_term.load() << std::endl;
        
        // 请求投票（简化版）
        // 实际实现需要向其他节点发送RPC请求
        simulateVoteResponses();
    }
    
    void becomeLeader() {
        state.store(NodeState::LEADER);
        std::cout << "[Node " << node_id << "] 成为Leader，任期: " 
                  << current_term.load() << std::endl;
    }
    
    void sendHeartbeats() {
        // 发送心跳给所有节点（简化版）
        // 实际实现需要向其他节点发送AppendEntries RPC
    }
    
    void simulateVoteResponses() {
        // 模拟投票响应（简化版）
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        
        // 假设有大多数节点投票
        int total_nodes = next_index.size() + 1;
        int majority = total_nodes / 2 + 1;
        
        if (voted_count.load() >= majority) {
            becomeLeader();
        }
    }
};

// 使用示例
int main() {
    std::cout << "=== 专家级：分布式状态机（Raft简化版） ===" << std::endl;
    
    std::vector<int> peer_ids = {1, 2};
    
    RaftNode node0(0, peer_ids);
    RaftNode node1(1, {0, 2});
    RaftNode node2(2, {0, 1});
    
    node0.start();
    node1.start();
    node2.start();
    
    // 等待选举完成
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    std::cout << "\n节点0状态: " << node0.getStateName() << std::endl;
    std::cout << "节点1状态: " << node1.getStateName() << std::endl;
    std::cout << "节点2状态: " << node2.getStateName() << std::endl;
    
    // Leader追加命令
    if (node0.getStateName() == "LEADER") {
        node0.appendCommand("SET key1 value1");
        node0.appendCommand("SET key2 value2");
    }
    
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    node0.stop();
    node1.stop();
    node2.stop();
    
    std::cout << "\n=== 所有节点已停止 ===" << std::endl;
    
    return 0;
}

2.3 状态机代码生成器

cpp 复制代码

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <fstream>
#include <sstream>

// 状态机定义
struct StateMachineDefinition {
    std::string name;
    std::vector<std::string> states;
    std::vector<std::string> events;
    std::map<std::string, std::map<std::string, std::string>> transitions;  // from -> event -> to
};

class StateMachineCodeGenerator {
public:
    static void generate(const StateMachineDefinition& def, const std::string& filename) {
        std::ofstream file(filename);
        if (!file.is_open()) {
            std::cerr << "无法创建文件: " << filename << std::endl;
            return;
        }
        
        generateHeader(file, def);
        generateStateEnum(file, def);
        generateEventEnum(file, def);
        generateStateMachineClass(file, def);
        generateImplementation(file, def);
        
        file.close();
        std::cout << "状态机代码已生成: " << filename << std::endl;
    }
    
private:
    static void generateHeader(std::ofstream& file, const StateMachineDefinition& def) {
        file << "// 自动生成的状态机代码\n";
        file << "// 状态机名称: " << def.name << "\n";
        file << "// 生成时间: " << __TIMESTAMP__ << "\n\n";
        file << "#ifndef " << def.name << "_H\n";
        file << "#define " << def.name << "_H\n\n";
        file << "#include <iostream>\n";
        file << "#include <string>\n";
        file << "#include <map>\n\n";
    }
    
    static void generateStateEnum(std::ofstream& file, const StateMachineDefinition& def) {
        file << "enum class " << def.name << "State {\n";
        for (size_t i = 0; i < def.states.size(); ++i) {
            file << "    " << def.states[i];
            if (i < def.states.size() - 1) file << ",";
            file << "\n";
        }
        file << "};\n\n";
    }
    
    static void generateEventEnum(std::ofstream& file, const StateMachineDefinition& def) {
        file << "enum class " << def.name << "Event {\n";
        for (size_t i = 0; i < def.events.size(); ++i) {
            file << "    " << def.events[i];
            if (i < def.events.size() - 1) file << ",";
            file << "\n";
        }
        file << "};\n\n";
    }
    
    static void generateStateMachineClass(std::ofstream& file, const StateMachineDefinition& def) {
        file << "class " << def.name << "StateMachine {\n";
        file << "private:\n";
        file << "    " << def.name << "State current_state;\n";
        file << "    std::map<" << def.name << "State, \n";
        file << "            std::map<" << def.name << "Event, " << def.name << "State>> transition_table;\n\n";
        file << "public:\n";
        file << "    " << def.name << "StateMachine();\n";
        file << "    bool handleEvent(" << def.name << "Event event);\n";
        file << "    " << def.name << "State getCurrentState() const { return current_state; }\n";
        file << "    std::string getStateName() const;\n";
        file << "    std::string getEventName(" << def.name << "Event event) const;\n";
        file << "};\n\n";
    }
    
    static void generateImplementation(std::ofstream& file, const StateMachineDefinition& def) {
        file << "#endif // " << def.name << "_H\n\n";
        file << "// 实现文件: " << def.name << ".cpp\n\n";
        file << "#include \"" << def.name << ".h\"\n\n";
        
        // 构造函数
        file << def.name << "StateMachine::" << def.name << "StateMachine() : current_state(" 
             << def.name << "State::" << def.states[0] << ") {\n";
        file << "    // 初始化状态转换表\n";
        
        for (const auto& [from_state, transitions] : def.transitions) {
            for (const auto& [event, to_state] : transitions) {
                file << "    transition_table[" << def.name << "State::" << from_state 
                     << "][" << def.name << "Event::" << event << "] = " 
                     << def.name << "State::" << to_state << ";\n";
            }
        }
        
        file << "}\n\n";
        
        // handleEvent
        file << "bool " << def.name << "StateMachine::handleEvent(" << def.name << "Event event) {\n";
        file << "    auto it = transition_table.find(current_state);\n";
        file << "    if (it == transition_table.end()) return false;\n\n";
        file << "    auto event_it = it->second.find(event);\n";
        file << "    if (event_it == it->second.end()) return false;\n\n";
        file << "    " << def.name << "State new_state = event_it->second;\n";
        file << "    std::cout << \"[\" << getStateName() << \"] --[\" \n";
        file << "              << getEventName(event) << \"]--> \" \n";
        file << "              << \"" << def.name << "State::\" << static_cast<int>(new_state) << std::endl;\n";
        file << "    current_state = new_state;\n";
        file << "    return true;\n";
        file << "}\n\n";
        
        // getStateName
        file << "std::string " << def.name << "StateMachine::getStateName() const {\n";
        file << "    switch (current_state) {\n";
        for (const auto& state : def.states) {
            file << "        case " << def.name << "State::" << state << ": return \"" << state << "\";\n";
        }
        file << "        default: return \"UNKNOWN\";\n";
        file << "    }\n";
        file << "}\n\n";
        
        // getEventName
        file << "std::string " << def.name << "StateMachine::getEventName(" << def.name << "Event event) const {\n";
        file << "    switch (event) {\n";
        for (const auto& event : def.events) {
            file << "        case " << def.name << "Event::" << event << ": return \"" << event << "\";\n";
        }
        file << "        default: return \"UNKNOWN\";\n";
        file << "    }\n";
        file << "}\n";
    }
};

// 使用示例
int main() {
    std::cout << "=== 专家级：状态机代码生成器 ===" << std::endl;
    
    // 定义一个简单的订单状态机
    StateMachineDefinition order_fsm;
    order_fsm.name = "Order";
    
    order_fsm.states = {"DRAFT", "PENDING_PAYMENT", "PAID", "SHIPPED", "DELIVERED", "COMPLETED"};
    order_fsm.events = {"CREATE", "SUBMIT", "PAY", "SHIP", "DELIVER", "COMPLETE"};
    
    order_fsm.transitions["DRAFT"]["CREATE"] = "DRAFT";
    order_fsm.transitions["DRAFT"]["SUBMIT"] = "PENDING_PAYMENT";
    order_fsm.transitions["PENDING_PAYMENT"]["PAY"] = "PAID";
    order_fsm.transitions["PENDING_PAYMENT"]["CANCEL"] = "CANCELLED";
    order_fsm.transitions["PAID"]["SHIP"] = "SHIPPED";
    order_fsm.transitions["SHIPPED"]["DELIVER"] = "DELIVERED";
    order_fsm.transitions["DELIVERED"]["COMPLETE"] = "COMPLETED";
    
    // 生成代码
    StateMachineCodeGenerator::generate(order_fsm, "OrderStateMachine.h");
    
    std::cout << "\n生成的代码示例：" << std::endl;
    std::ifstream generated("OrderStateMachine.h");
    std::string line;
    int line_count = 0;
    while (std::getline(generated, line) && line_count < 50) {
        std::cout << line << std::endl;
        line_count++;
    }
    generated.close();
    
    return 0;
}

专家级总结

📝 核心概念回顾

任务调度：

协程调度：轻量级并发
无锁队列：极致性能优化
自适应负载均衡：智能资源分配
事件溯源：状态可追溯和重放
分布式状态机：高可用性和一致性
代码生成：自动化和类型安全
理解并能实现协程调度器
掌握无锁编程技术
能够设计自适应负载均衡算法
理解事件溯源模式
了解分布式一致性算法（如Raft）
能够设计代码生成工具

C++任务调度与状态机

一、任务调度基础

1.1 什么是任务调度？

1.2 最简单的任务调度 - 使用 std::thread

1.3 使用 std::async 简化异步任务

1.4 实战：简单的定时任务调度器

二、状态机基础

2.1 什么是状态机？

2.2 最简单的状态机 - if-else 实现

2.3 改进：使用 switch-case 的状态机

2.4 实战：简单的订单状态机

📝 核心概念回顾

✅ 入门级掌握标准

✅ 进阶级掌握标准

第三阶段：高阶级 🎓

一、高级任务调度技术

1.1 任务窃取（Work Stealing）

✅ 高阶级掌握标准

第四阶段：专家级 🌟

一、专家级任务调度架构

1.1 基于C++20协程的调度器

✅ 专家级掌握标准

第二阶段：进阶级 🚀

一、面向对象的任务调度

1.1 线程池模式

1.2 任务优先级调度

1.3 实战：Web服务器请求调度器

二、面向对象的状态机

2.1 状态模式（State Pattern）

2.3 实战：TCP连接状态机

进阶级总结

📝 核心概念回顾

1.2 延迟任务调度

1.3 分布式任务调度框架

二、高级状态机技术

2.1 层次化状态机（HSM - Hierarchical State Machine）

2.2 状态机持久化

2.3 状态机监控与日志

高阶级总结

📝 核心概念回顾

1.2 无锁任务队列

1.3 自适应负载均衡调度器

二、专家级状态机架构

2.1 基于事件溯源的状态机

2.2 分布式状态机（Raft算法简化版）

2.3 状态机代码生成器

专家级总结

📝 核心概念回顾