C++ code:

#include <map>
#include <mutex>
#include <tuple>

template <typename Value, typename F, typename ...Args>
class memo {
private:
    F calculate_;
    std::map<std::tuple<Args...>, Value> results_;
    std::mutex results_mutex_;
    // ^ lock before accessing results_
    std::map<std::tuple<Args...>, std::once_flag> calculation_flags_;
    std::mutex calc_flags_mutex_;
    // ^ lock before accessing calculation_flags_
public:
    /* Construct a memo, which stores a function `calculate` which takes
     * arguments of types `Args...` and which returns an object of type `Value`.
     * This memo will then store the results of `calculate` for each set of
     * arguments passed to `get()`, so that `calculate` is only called once
     * for each set of arguments.
     */
    explicit memo(F calculate): calculate_(calculate) {}

    /* Get the result for the memoized function given the arguments `args`. The
     * memoized function is called exactly once. Multiple concurrent calls to
     * `get` are thread safe, with all calls hanging until the stored calculation
     */
    Value get(Args... args) {
        auto key = std::make_tuple(args...);
        {
            std::lock_guard<std::mutex> calc_flags_lock(calc_flags_mutex_);
            // Add a once flag for `args` if it doesn't already exist
            // Note: map.emplace() will not overwrite a duplicate key
            calculation_flags_.emplace(
                std::piecewise_construct,
                std::forward_as_tuple(key),
                std::forward_as_tuple()
                // ^ gotta jump through hoops to avoid copying a once_flag
            );
        }
        std::call_once(
            calculation_flags_.at(key),
            [this, &key, &args...] () {
                Value result = calculate_(args...);
                std::lock_guard<std::mutex> results_lock_(results_mutex_);
                results_.emplace(key, result);
            }
        );
        std::lock_guard<std::mutex> results_lock_(results_mutex_);
        return results_.at(key);
    }
};