C++11 条件变量（condition_variable） 使用详解

C++11 条件变量（condition_variable） 使用详解 - 小海哥哥de - 博客园 (cnblogs.com)

在C++11中，我们可以使用条件变量（condition_variable）实现多个线程间的同步操作；当条件不满足时，相关线程被一直阻塞，直到某种条件出现，这些线程才会被唤醒。

主要成员函数如下：

(651条消息) vsomeip-双机通信例子_vsomeip json配置_Sherry Baron的博客-CSDN博客
 

#include <iostream>           // std::cout
#include <thread>             // std::thread
#include <chrono>             // std::chrono::seconds
#include <mutex>              // std::mutex, std::unique_lock
#include <condition_variable> // std::condition_variable, std::cv_status
 
std::condition_variable cv;
int value;
 
void do_read_value()
{
    std::cin >> value;
    cv.notify_one();
}
 
int main ()
{
    std::cout << "Please, enter an integer (I'll be printing dots): \n";
    std::thread th(do_read_value);
 
    std::mutex mtx;
    std::unique_lock<std::mutex> lck(mtx);
    while (cv.wait_for(lck,std::chrono::seconds(1)) == std::cv_status::timeout) {
        std::cout << '.';
        std::cout.flush();
    }
    std::cout << "You entered: " << value << '\n';
    th.join();
    return 0;
}

C++ std::condition_variable wait() wait_for() 区别 怎么用 实例_condition_variable wait_for-CSDN博客

• std::unique_lock<std::mutex> its_lock(mutex);

  • condition.wait(its_lock);        //主线程不起作用，必须是子线程..

 

#include <condition_variable>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <thread>
#include <vsomeip/vsomeip.hpp>

#define SAMPLE_SERVICE_ID 0x1234
#define SAMPLE_INSTANCE_ID 0x5678
#define SAMPLE_METHOD_ID 0x07
#define SAMPLE_EVENTGROUP_ID 0x5555
#define SAMPLE_EVENT_ID 9001

std::shared_ptr<vsomeip::application> app;
std::mutex mutex;
std::condition_variable condition;

void run() {
    std::unique_lock<std::mutex> its_lock(mutex);
    condition.wait(its_lock);
	//注册监听
    std::set<vsomeip::eventgroup_t> its_groups;
    its_groups.insert(SAMPLE_EVENTGROUP_ID);
    app->request_event(SAMPLE_SERVICE_ID, SAMPLE_INSTANCE_ID, SAMPLE_EVENT_ID, its_groups, true);
    app->request_event(SAMPLE_SERVICE_ID, SAMPLE_INSTANCE_ID, SAMPLE_EVENT_ID + 1, its_groups, true);
    app->subscribe(SAMPLE_SERVICE_ID, SAMPLE_INSTANCE_ID, SAMPLE_EVENTGROUP_ID);

    // Send Request
    std::shared_ptr<vsomeip::message> request;
    request = vsomeip::runtime::get()->create_request(true);
    request->set_service(SAMPLE_SERVICE_ID);
    request->set_instance(SAMPLE_INSTANCE_ID);
    request->set_method(SAMPLE_METHOD_ID);

    std::shared_ptr<vsomeip::payload> its_payload = vsomeip::runtime::get()->create_payload();
    std::vector<vsomeip::byte_t> its_payload_data;
    for (vsomeip::byte_t i = 0; i < 10; i++) {
        its_payload_data.push_back(i % 256);
    }
    its_payload->set_data(its_payload_data);
    request->set_payload(its_payload);
    app->send(request, true);
  
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    // send field request
    std::shared_ptr<vsomeip::message> request_filed;
    request_filed = vsomeip::runtime::get()->create_request(true);
    request_filed->set_service(SAMPLE_SERVICE_ID);
    request_filed->set_instance(SAMPLE_INSTANCE_ID);
    request_filed->set_method(SAMPLE_EVENT_ID);
    std::shared_ptr<vsomeip::payload> filed_payload = vsomeip::runtime::get()->create_payload();
    const vsomeip::byte_t its_data[] = {0x12};
    filed_payload->set_data(its_data, sizeof(its_data));
    request_filed->set_payload(filed_payload);
    app->send(request_filed, true);
}

void on_message(const std::shared_ptr<vsomeip::message>& _response) {
    std::stringstream its_message;
    its_message << "CLIENT: received a notification for event [" << std::setw(4)
                << std::setfill('0') << std::hex << _response->get_service() << "." << std::setw(4)
                << std::setfill('0') << std::hex << _response->get_instance() << "." << std::setw(4)
                << std::setfill('0') << std::hex << _response->get_method()
                << "message_type: " << std::hex << static_cast<int>(_response->get_message_type())
                << "] to Client/Session [" << std::setw(4) << std::setfill('0') << std::hex
                << _response->get_client() << "/" << std::setw(4) << std::setfill('0') << std::hex
                << _response->get_session() << "] = ";
    std::shared_ptr<vsomeip::payload> its_payload = _response->get_payload();
    its_message << "(" << std::dec << its_payload->get_length() << ") ";
    for (uint32_t i = 0; i < its_payload->get_length(); ++i)
        its_message << std::hex << std::setw(2) << std::setfill('0')
                    << (int)its_payload->get_data()[i] << " ";
    std::cout << its_message.str() << std::endl;

}

void on_availability(vsomeip::service_t _service, vsomeip::instance_t _instance,
                     bool _is_available) {
    std::cout << "CLIENT: Service [" << std::setw(4) << std::setfill('0') << std::hex << _service
              << "." << _instance << "] is " << (_is_available ? "available." : "NOT available.")
              << std::endl;
    if (_is_available) {
        condition.notify_one();
    }
}

void on_state_cbk(vsomeip::state_type_e _state) {
    std::cout << "on_state_cbk, state: " << static_cast<int>(_state) << std::endl;
    if (_state == vsomeip::state_type_e::ST_REGISTERED) {
        //注册成功后请求service，然后等待on_availability的callback
        // we are registered at the runtime now we can request the service
        // and wait for the on_availability callback to be called
        app->request_service(SAMPLE_SERVICE_ID, SAMPLE_INSTANCE_ID);
    }
}

int main() {
    app = vsomeip::runtime::get()->create_application("Hello");

    std::set<vsomeip::eventgroup_t> its_groups;
    its_groups.insert(SLAVE_EVENTGROUP_ID);

    app->init();

    //把这个application注册到路由管理器中，on_state_cbk：callback注册结果
    app->register_state_handler(on_state_cbk);

    app->register_availability_handler(SAMPLE_SERVICE_ID, SAMPLE_INSTANCE_ID, on_availability);
    app->register_message_handler(vsomeip::ANY_SERVICE, vsomeip::ANY_INSTANCE, vsomeip::ANY_METHOD,
                                  on_message);
    std::thread sender(run);
    app->start();
}