std::this_thread::sleep_until(）和std::this_thread::sleep_for()

`std::this_thread::sleep_until()` 和 `std::this_thread::sleep_for()` 是C++标准库中用于线程同步的函数，它们分别属于 `<thread>` 头文件。这两个函数都用来让当前线程暂停执行，直到指定的时间点。

1. `std::this_thread::sleep_until(time_point)`
这个函数接受一个 `std::chrono::time_point<std::chrono::system_clock>` 类型的参数，表示到某个特定的时间点。线程会一直睡眠，直到 `system_clock`（系统时钟）的指定时间点到来。如果目标时间点已经过去，线程不会等待，而是立即返回。

2. `std::this_thread::sleep_for(duration)`
这个函数接受一个 `std::chrono::duration` 类型的参数，比如 `std::chrono::seconds`, `std::chrono::milliseconds` 等，代表一个持续时间。线程会暂停执行指定的秒数或毫秒数，然后继续执行。

使用这两个函数时需要注意：
- 线程会在等待期间被调度其他任务，除非它是被阻塞在一个锁或其他同步原语上。
- 如果睡眠时间小于实际耗时（如由于系统调度），线程可能会提前唤醒。

相关问题

mutable std::condition_variable_any sendAndBlockCondition_; wait_until接口解读

`std::condition_variable_any`是一个通用的条件变量类，它可以与任何可锁定类型一起使用。`wait_until`是`std::condition_variable_any`类的一个成员函数，用于在指定的时间点等待条件变量。

`wait_until`函数的语法如下：

template<class Lockable, class Predicate>
std::cv_status wait_until(Lockable& lock, const std::chrono::time_point<Clock, Duration>& abs_time, Predicate pred);

参数解释：
- `lock`：一个可锁定的对象，用于保护条件变量。
- `abs_time`：一个`std::chrono::time_point`类型的参数，表示等待的终止时间点。
- `pred`：一个可调用对象，用于检查条件是否满足。如果条件不满足，线程将一直等待。

`wait_until`函数的工作原理如下：
1. 线程调用`wait_until`函数并传入`lock`对象、终止时间点和条件检查函数。
2. 如果条件满足，`wait_until`函数立即返回`std::cv_status::no_timeout`。
3. 如果条件不满足，`wait_until`函数将线程置于等待状态，直到满足以下任一条件：
- 终止时间点到达。
- 其他线程调用了与`condition_variable_any`对象关联的`notify_one`或`notify_all`函数。
- 线程被中断。
4. 如果线程被唤醒并且条件满足，`wait_until`函数返回`std::cv_status::no_timeout`。
5. 如果线程被唤醒但是终止时间点到达，`wait_until`函数返回`std::cv_status::timeout`。

下面是一个示例代码，演示了如何使用`wait_until`函数：

#include <iostream>
#include <condition_variable>
#include <mutex>
#include <chrono>
#include <thread>

std::condition_variable_any cv;
std::mutex mtx;
bool ready = false;

void worker()
{
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::unique_lock<std::mutex> lock(mtx);
    ready = true;
    cv.notify_one();
}

int main()
{
    std::unique_lock<std::mutex> lock(mtx);
    std::chrono::system_clock::time_point timeout = std::chrono::system_clock::now() + std::chrono::seconds(5);
    while (!ready)
    {
        if (cv.wait_until(lock, timeout) == std::cv_status::timeout)
        {
            std::cout << "Timeout occurred!" << std::endl;
            break;
        }
    }
    if (ready)
    {
        std::cout << "Condition satisfied!" << std::endl;
    }
    return 0;
}

using clock_type = std::chrono::system_clock; struct message { clock_type::time_point when; std::function<void()> callback; std::string param; }; class message_loop { public: message_loop(): _stop(false) { // } message_loop(const message_loop&) = delete; message_loop& operator=(const message_loop&) = delete; void run() { while (!_stop) { auto msg = wait_one(); msg.callback(); } } void quit() { post({clock_type::now(), this{ _stop = true; } }); } void post(std::function<void()> callable) { post({clock_type::now(), std::move(callable)}); } void post(std::function<void()> callable, std::chrono::milliseconds delay) { post({clock_type::now() + delay, std::move(callable)}); } private: struct msg_prio_comp { inline bool operator() (const message& a, const message& b) { return a.when > b.when; } }; using queue_type = std::priority_queue<message, std::vector<message>, msg_prio_comp>; std::mutex _mtx; std::condition_variable _cv; queue_type _msgs; bool _stop; void post(message msg) { auto lck = acquire_lock(); _msgs.emplace(std::move(msg)); _cv.notify_one(); } std::unique_lockstd::mutex acquire_lock() { return std::unique_lockstd::mutex(_mtx); } bool idle() const { return _msgs.empty(); } const message& top() const { return _msgs.top(); } message pop() { auto msg = top(); _msgs.pop(); return msg; } message wait_one() { while (true) { auto lck = acquire_lock(); if (idle()) _cv.wait(lck); else if (top().when <= clock_type::now()) return pop(); else { _cv.wait_until(lck, top().when); // 可能是新消息到达，再循环一次看看 } } } }; int main(int argc, char *argv[]) { using namespace std; using namespace std::chrono; message_loop *pLoop = new message_loop; thread th(pLoop{ pLoop->run(); }); cout << "POST 1"<<endl;; pLoop->post({ cout << "1"<<endl; }); cout << "POST 2"<<endl;; pLoop->post({ cout << "2"<<endl; }, milliseconds(500)); cout << "POST 3"<<endl;; pLoop->post({ cout << "3"<<endl; }); cout << "POST 4"<<endl;; pLoop->post({ cout << "4"<<endl; }, milliseconds(1000)); this_thread::sleep_for(milliseconds(1500)); // pLoop->quit(); cout << "Quit"<<endl; th.join(); cout << "here"<<endl; } 请优化一下，可以传参

可以将 message 结构体中的 param 字段用于传递参数，并相应地修改 post 函数和 wait_one 函数。具体代码如下：

using clock_type = std::chrono::system_clock;

struct message {
    clock_type::time_point when;
    std::function<void(const std::string&)> callback;
    std::string param;
};

class message_loop {
public:
    message_loop() : _stop(false) {}

    message_loop(const message_loop&) = delete;
    message_loop& operator=(const message_loop&) = delete;

    void run() {
        while (!_stop) {
            auto msg = wait_one();
            msg.callback(msg.param);
        }
    }

    void quit() {
        post({clock_type::now(), [](const std::string&) {}}, "");
        _stop = true;
    }

    void post(std::function<void(const std::string&)> callable, const std::string& param) {
        post({clock_type::now(), std::move(callable), param});
    }

    void post(std::function<void(const std::string&)> callable, std::chrono::milliseconds delay, const std::string& param) {
        post({clock_type::now() + delay, std::move(callable), param});
    }

private:
    struct msg_prio_comp {
        inline bool operator() (const message& a, const message& b) {
            return a.when > b.when;
        }
    };

    using queue_type = std::priority_queue<message, std::vector<message>, msg_prio_comp>;

    std::mutex _mtx;
    std::condition_variable _cv;
    queue_type _msgs;
    bool _stop;

    void post(message msg) {
        auto lck = acquire_lock();
        _msgs.emplace(std::move(msg));
        _cv.notify_one();
    }

    std::unique_lock<std::mutex> acquire_lock() {
        return std::unique_lock<std::mutex>(_mtx);
    }

    bool idle() const {
        return _msgs.empty();
    }

    const message& top() const {
        return _msgs.top();
    }

    message pop() {
        auto msg = top();
        _msgs.pop();
        return msg;
    }

    message wait_one() {
        while (true) {
            auto lck = acquire_lock();
            if (idle()) {
                _cv.wait(lck);
            } else if (top().when <= clock_type::now()) {
                auto msg = pop();
                return msg;
            } else {
                _cv.wait_until(lck, top().when);
                // 可能是新消息到达，再循环一次看看
            }
        }
    }
};

int main(int argc, char *argv[]) {
    using namespace std;
    using namespace std::chrono;

    message_loop *pLoop = new message_loop;
    thread th(pLoop, &message_loop::run);

    pLoop->post([](const std::string& param) { cout << "1 " << param << endl; }, "hello");
    pLoop->post([](const std::string& param) { cout << "2 " << param << endl; }, milliseconds(500), "world");
    pLoop->post([](const std::string& param) { cout << "3 " << param << endl; }, "foo");
    pLoop->post([](const std::string& param) { cout << "4 " << param << endl; }, milliseconds(1000), "bar");

    this_thread::sleep_for(milliseconds(1500));

    pLoop->quit();

    th.join();
}