用C++的std::thread实现一个类似::base::SequencedTaskRunner的功能，并且在另一个类中使用这个类的postTask方法

以下是一个简单的实现：

#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>

class SequencedTaskRunner {
public:
    SequencedTaskRunner() : stop(false) {
        thread = std::thread(&SequencedTaskRunner::run, this);
    }

    ~SequencedTaskRunner() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_one();
        thread.join();
    }

    void postTask(std::function<void()> task) {
        std::unique_lock<std::mutex> lock(queue_mutex);
        task_queue.push(task);
        condition.notify_one();
    }

private:
    std::thread thread;
    std::queue<std::function<void()>> task_queue;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;

    void run() {
        while (true) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lock(queue_mutex);
                condition.wait(lock, [this](){ return !task_queue.empty() || stop; });
                if (stop && task_queue.empty()) {
                    return;
                }
                task = std::move(task_queue.front());
                task_queue.pop();
            }
            task();
        }
    }
};

class AnotherClass {
public:
    AnotherClass() {
        task_runner = std::make_unique<SequencedTaskRunner>();
    }

    void someMethod() {
        task_runner->postTask([](){
            // do something
        });
    }

private:
    std::unique_ptr<SequencedTaskRunner> task_runner;
};

在这个实现中，我们使用了一个std::queue来存储任务，一个std::mutex来同步访问任务队列，一个std::condition_variable来实现等待任务队列非空的条件，并且在任务执行完成后再次等待。我们还使用了一个bool变量stop来指示线程是否应该退出。在SequencedTaskRunner的析构函数中，我们设置stop为true并且唤醒线程，以便线程可以退出。

在AnotherClass中，我们创建了一个SequencedTaskRunner，并且在someMethod中使用postTask方法来提交任务。这个方法会将任务添加到task_queue中，并且唤醒线程以便它可以执行任务。

这个实现只是一个简单的示例，可以根据需要进行修改和扩展。