C++-ში std::future რა არის?

std::future — ეს C++-ის შაბლონის კლასი, რომელიც წარმოადგენს ასინქრონული ოპერაციის შედეგს (მნიშვნელობას ან გამონაკლისს), რომელიც მომავალში იქნება ხელმისაწვდომი. იგი გამოიყენება ამოცანის შესრულების შედეგის მიღებისთვის, რომელიც დაიწყო ცალკე ნაკადში ან std::async-ის საშუალებით:

ძირითადი მახასიათებლები:

• ასინქრონული: საშუალებას აძლევს ოპერაციის შესრულებას, არ ბლოკავს მიმდინარე ნაკადს.
• შედეგის მიღება: get() მეთოდი საშუალებას აძლევს მიიღოს ოპერაციის შედეგი. თუ შედეგი ჯერ არ არის მზად, get() ბლოკავს მიმდინარე ნაკადს მის მზადყოფნამდე ან გამონაკლისის მიღებამდე.
• მონაცემთა გადაცემა: დაკავშირებულია std::promise ობიექტთან, რომელიც უზრუნველყოფს შედეგის ან გამონაკლისის დაყენების საშუალებას.
• სტატუსი: std::future-ს აქვს მდგომარეობა, რომელიც მიუთითებს, მზად არის თუ არა შედეგი. შემოწმება შეიძლება wait() ან wait_for()-ით.
• მარტო ერთხელ მიღება: get() მეთოდი შეიძლება გამოიძახოს მხოლოდ ერთხელ თითო std::future ობიექტზე.
• შედეგის ტიპი: განსაზღვრულია ასინქრონული ოპერაციის დაბრუნებული მნიშვნელობით.

მაგალითი std::async-თან ერთად:

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

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

// მაგალითი `std::future`-ის გამოყენების `std::async`-თან
int main() {
    // ასინქრონული ოპერაციის დაწყება
    std::future<int> result_future = std::async(std::launch::async, calculate_something);

    // სხვა სამუშაოების შესრულება, სანამ ოპერაცია მიმდინარეობს
    std::cout << "Doing something else..." << std::endl;

    // შედეგის მიღება (ბლოკირება, თუ ჯერ არ არის მზად)
    int result = result_future.get();
    std::cout << "Result is: " << result << std::endl;

    return 0;
}

მაგალითი std::promise-თან ერთად:

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

void worker_function(std::promise<int> promise_obj) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    // შედეგის დაყენება
    promise_obj.set_value(123);
}

// მაგალითი `std::future`-ის გამოყენების `std::promise`-თან
int main() {
    // `promise` და `future` შექმნა
    std::promise<int> promise_obj;
    std::future<int> future_obj = promise_obj.get_future();

    // სამუშაოს გამოძახება ცალკე ნაკადში, `promise`-ის გადაცემით
    std::thread worker_thread(worker_function, std::move(promise_obj));

    // სხვა სამუშაოების შესრულება, სანამ worker მუშაობს
    std::cout << "Doing something else..." << std::endl;

    // შედეგის მიღება (ბლოკირება, თუ ჯერ არ არის მზად)
    int result = future_obj.get();
    std::cout << "Result from worker: " << result << std::endl;

    // worker ნაკადის შეჩერება
    worker_thread.join();

    return 0;
}

std::future-ის მნიშვნელოვანი მეთოდები:

მეთოდი	აღწერა
get()	იღებს შედეგს. ბლოკავს, თუ შედეგი ჯერ არ არის მზად. შეიძლება გამოიძახოს მხოლოდ ერთხელ.
valid()	ამოწმებს, არის თუ არა std::future დაკავშირებული ასინქრონული ოპერაციის საერთო მდგომარეობასთან.
wait()	ბლოკავს მიმდინარე ნაკადს მანამ, სანამ შედეგი არ გახდება ხელმისაწვდომი (ან გამონაკლისი არ გამოიწვიოს).
wait_for()	ელოდება შედეგს მითითებულ დროის ინტერვალში. აბრუნებს ელოდების სტატუსს.
wait_until()	ელოდება შედეგს მითითებულ დროის წერტილამდე. აბრუნებს ელოდების სტატუსს.

std::future ნაწილია <future> ბიბლიოთეკის და უზრუნველყოფს კომფორტულ გზას ასინქრონული გამოთვლების შედეგების მართვისთვის, რაც ამარტივებს მრავალთრედული პროგრამების შემუშავებას.