Új hozzászólás Aktív témák

• #22848 cog777 őstag Aryes #22847

  Új Válasz 2024-09-09 15:24:46 #22848

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  cog777

  őstag

  válasz Aryes #22847 üzenetére

  Hianyoltam az egyszeru kommunikaciot a szalak kozott, regebben Qt-t es Boost signal-t hasznaltam. Aztan kiderult hogy tok egyszeru a promise-al kuldeni adatot a belole kinyert future-be.

  Itt van egy masik pelda adatcserere, a producer megvarja amig a consumer elindult, majd kuldi az adatot. Az egyik direkt async-et hasznal, a masik thread-et. FreeRTOS alatt a Thread ugyanugy FreeRTOS utasitasokat hasznal csak el van rejtve a stack meg egy csomo minden. De a Promise-future paros tenyleg nagyon jo. Ha megvan irva a move constructor es assignment operatora a struct-nak, akkor nincs nagy adatmozgas ha promise-t hasznalsz.
  Gyakorlatilag: konstruktor hivas, majd move konstruktor.

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

/*
Ez tortenik a struct keszitesekor:
ctor2
move ctor
move ctor
Received signal: 42

*/
struct data_s
{
data_s() { std::cout << "ctor1" << std::endl; }
data_s(int v) : data(v) { std::cout << "ctor2" << std::endl; }
data_s(data_s &&rhs) : data(std::move(rhs.data)) { std::cout << "move ctor" << std::endl; }
data_s &operator=(const data_s &rhs)
{
std::cout << "copy operator" << std::endl;
if (this == &rhs)
return *this;
data = rhs.data;
return *this;
}
data_s &operator=(data_s &&rhs)
{
std::cout << "move operator" << std::endl;

data = std::move(rhs.data);
return *this;
}
int data{0};
};

void task_consumer_fnc(std::future<data_s> &&f, std::promise<void> &&ready_signal)
{
ready_signal.set_value();
while (true)
{
if (f.wait_for(std::chrono::milliseconds(100)) == std::future_status::ready)
{
auto d = f.get();
std::cout << "Received signal: " << d.data << std::endl;
break;
}
}
}

void task_producer_fnc(std::promise<data_s> &&signal, std::shared_future<void> &&ready_slot)
{
ready_slot.get();
// std::this_thread::sleep_for(std::chrono::milliseconds(1000));
signal.set_value({42});
}

int main()
{
std::promise<data_s> signal;
auto slot = signal.get_future();

std::promise<void> ready_signal;
std::shared_future<void> ready_slot(ready_signal.get_future());

std::packaged_task<void(std::promise<data_s> &&, std::shared_future<void> &&)> task_producer(task_producer_fnc);
auto future_producer = std::async(std::launch::async, std::move(task_producer), std::move(signal), std::move(ready_slot));

std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::packaged_task<void(std::future<data_s> &&, std::promise<void> &&)> task_consumer(task_consumer_fnc);
std::thread thread(std::move(task_consumer), std::move(slot), std::move(ready_signal));
thread.join();
return 0;
}

Új hozzászólás Aktív témák