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;
}