std::shared_future::get(C++11)

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

void calc(std::promise<int> p)
{
  int sum = 0;
  for (int i = 0; i < 10; ++i) {
    sum += i + 1;
  }

  p.set_value(sum); // 結果値を書き込む
}

int main()
{
  std::promise<int> p;
  std::shared_future<int> f = p.get_future().share();

  // 別スレッドで計算を行う
  std::thread t(calc, std::move(p));

  // calc()によって書き込まれた結果を取得
  std::cout << f.get() << std::endl;

  t.join();
}

#include <iostream>
#include <future>
#include <thread>
#include <mutex>
#include <vector>
#include <utility>
#include <numeric>

std::mutex print_mtx_;
void print(int value, int thread_no)
{
  std::lock_guard<std::mutex> lk(print_mtx_);
  std::cout << "thread:" << thread_no << " sum:" << value << std::endl;
}

class X {
  std::vector<int> data_;
  std::vector<std::thread> process_threads_;
public:
  void start()
  {
    std::promise<void> p;
    std::shared_future<void> f = p.get_future().share();

    for (int i = 0; i < 2; ++i) {
      process_threads_.push_back(std::thread([&f, i, this] { process(f, i); }));
    }

    std::thread t3([&p, this] { read_data(std::move(p)); });
    t3.join();
  }

  void join()
  {
    for (std::thread& t : process_threads_) {
      t.join();
    }
  }

private:
  void read_data(std::promise<void> p)
  {
    // 1. データ読み込むj
    for (int i = 0; i < 10; ++i) {
      data_.push_back(i + 1);
    }

    // 2. 読み込みが完了したことを通知する
    p.set_value();
  }

  void process(std::shared_future<void> f, int thread_no)
  {
    // 3. データの準備ができるまで待機する
    f.get();

    // 4. 準備ができたデータをスレッドごとに使用する
    if (thread_no == 0) {
      // 半分ずつ合計値を計算する
      int sum = std::accumulate(data_.begin(), data_.begin() + data_.size() / 2, 0);
      print(sum, thread_no);
    }
    else {
      int sum = std::accumulate(data_.begin() + data_.size() / 2, data_.end(), 0);
      print(sum, thread_no);
    }
  }
};

int main()
{
  X x;
  x.start();
  x.join();
}