Mis on std::future C++-s?

std::future — see C++ malliklass, mis esindab asünkroonse operatsiooni tulemust (väärtust või erandit), mis saab olema kättesaadav tulevikus. Seda kasutatakse ülesande täitmise tulemuse saamiseks, mis on käivitatud eraldi lõimes või kaudu std::async:

Peamised omadused:

• Asünkroonsus: võimaldab täita operatsiooni ilma praegust lõime blokeerimata.
• Tulemuse saamine: get() meetod võimaldab saada operatsiooni tulemuse. Kui tulemus pole veel valmis, get() blokeerib praeguse lõime kuni see on valmis või erand visatakse.
• Andmete edastamine: seotud std::promise objektiga, mis võimaldab määrata tulemuse või erandi.
• Seisund: std::future omab seisundit, mis näitab, kas tulemus on valmis. Kontrollida saab wait() või wait_for() abil.
• Ainult üks kord: get() meetodit saab kutsuda ainult üks kord iga std::future objekti kohta.
• Tulemuse tüüp: määratud asünkroonse operatsiooni tagastatava väärtuse järgi.

Näide kasutades std::async-iga:

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

int calculate_something() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 42;
}

// Näide `std::future` kasutamisest `std::async`-iga
int main() {
    // Käivitame asünkroonse operatsiooni
    std::future<int> result_future = std::async(std::launch::async, calculate_something);

    // Teeme teisi töid, kuni operatsioon arvutatakse
    std::cout << "Doing something else..." << std::endl;

    // Saame tulemuse (blokeerib, kui see pole veel valmis)
    int result = result_future.get();
    std::cout << "Result is: " << result << std::endl;

    return 0;
}

Näide kasutades std::promise-ga:

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

void worker_function(std::promise<int> promise_obj) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    // Määrame tulemuse
    promise_obj.set_value(123);
}

// Näide `std::future` kasutamisest `std::promise`-ga
int main() {
    // Loome `promise` ja `future`
    std::promise<int> promise_obj;
    std::future<int> future_obj = promise_obj.get_future();

    // Käivitame töötaja eraldi lõimes, edastades `promise`
    std::thread worker_thread(worker_function, std::move(promise_obj));

    // Teeme teisi töid, kuni töötaja töötab
    std::cout << "Doing something else..." << std::endl;

    // Saame tulemuse (blokeerib, kui see pole veel valmis)
    int result = future_obj.get();
    std::cout << "Result from worker: " << result << std::endl;

    // Ootame töötaja lõime lõpetamist
    worker_thread.join();

    return 0;
}

Olulised std::future meetodid:

Meetod	Kirjeldus
get()	Saab tulemuse. Blokeerib, kui tulemus pole veel valmis. Võib kutsuda ainult üks kord.
valid()	Kontrollib, kas std::future on seotud üldise asünkroonse operatsiooni olekuga.
wait()	Blokeerib praeguse sraadi kuni tulemus on kättesaadav (või visatakse erand).
wait_for()	Ootab tulemust määratud aja jooksul. Tagastab ootamise staatuse.
wait_until()	Ootab tulemust kuni määratud ajahetkeni. Tagastab ootamise staatuse.

std::future on <future> teegis ja pakub mugavat viisi asünkroonsete arvutuste tulemuste haldamiseks, lihtsustades mitme lõimega rakenduste arendamist.