与std :: chrono :: high_resolution_clock在班级内播种STD :: MT19937的

我被告知，只有一旦播种任何随机发动机

才是一个好习惯

听起来像是合理的建议。我想补充一点，您最好每个线程完全具有一个发电机，因为实例化和播种需要时间，并且标准发电机不安全。

我认为std::random_device不是真正可靠的

应该能够通过其entropy()函数告诉您它是否是通过其CC_6函数。零熵表示其熵池是空的，甚至不存在。在后一种情况下，您会从中获得伪随机数。

正确的方法是什么...

通过阅读评论和其他一些提示中的链接，这就是我到目前为止收集的：

• 创建一个种子序列类，该类别创建与生成器所需的种子值一样多。如果std::random_device中的熵为零，请将其尽可能地与其他来源结合在一起。我认为Hashed time_point样本花了一段时间可以与rd()结合使用，因为在输入值中1个更改位应理想地更改Hashed值的一半位。
• 创建一个共享生成器，该发电机会自动实例化和从(新(线程要求时进行播种，因为因为发电机不是线程安全的。
• 创建从生成器继承的分布模板，以便一个线程中的所有分布共享同一生成器。
• 不要实例化分布超出必要。如果您经常使用相同的发行版，请保留。

这是代码中注释的尝试：

#include <iostream>
#include <chrono>
#include <climits>
#include <functional>
#include <iterator>
#include <random>
#include <thread>
#include <type_traits>
#include <utility>
//----------------------------------------------------------------------------------
// sexmex - A hash function kindly borrowed from Pelle Evensens yet to be published
// work: http://mostlymangling.blogspot.com/
//
// g++ 8.3.1: std::hash<Integer-type> lets the value through as-is (identity)
//            so I'll use this to create proper hash values instead.
template<typename Out = size_t, typename In>
inline std::enable_if_t<sizeof(In) * CHAR_BIT <= 64 &&
                            std::numeric_limits<Out>::is_integer &&
                            std::numeric_limits<In>::is_integer,
                        Out>
sexmex(In v) {
    uint64_t v2 = static_cast<uint64_t>(v); // cast away signedness
    v2 ^= (v2 >> 20) ^ (v2 >> 37) ^ (v2 >> 51);
    v2 *= 0xA54FF53A5F1D36F1ULL; // Fractional part of sqrt(7)
    v2 ^= (v2 >> 20) ^ (v2 >> 37) ^ (v2 >> 51);
    v2 *= 0x510E527FADE682D1ULL; // Fractional part of sqrt(11)
    v2 ^= (v2 >> 20) ^ (v2 >> 37) ^ (v2 >> 51);
    // Discard the high bits if Out is < 64 bits. This particular hash function
    // has not shown any weaknesses in the lower bits in any widely known test
    // suites yet.
    return static_cast<Out>(v2);
}
//----------------------------------------------------------------------------------
class seeder {
public:
    using result_type = std::uint_least32_t;
    // function called by the generator on construction to fill its internal state
    template<class RandomIt>
    void generate(RandomIt Begin, RandomIt End) const noexcept {
        using seed_t = std::remove_reference_t<decltype(*Begin)>;
        std::random_device rd{};
        if(rd.entropy() == 0.) { // check entropy
            // zero entropy, add some
            constexpr auto min = std::chrono::high_resolution_clock::duration::min();
            std::vector<seed_t> food_for_generator(
                static_cast<size_t>(std::distance(Begin, End)));
            for(int stiring = 0; stiring < 10; ++stiring) {
                for(auto& food : food_for_generator) {
                    // sleep a little to ensure a new clock count each iteration
                    std::this_thread::sleep_for(min);
                    std::this_thread::sleep_for(min);
                    auto cc = std::chrono::high_resolution_clock::now()
                                  .time_since_epoch()
                                  .count();
                    food ^= sexmex<seed_t>(cc);
                    food ^= sexmex<seed_t>(rd());
                }
                stir_buffer(food_for_generator);
            }
            // seed the generator
            for(auto f = food_for_generator.begin(); Begin != End; ++f, ++Begin)
                *Begin = *f;
        } else {
            // we got entropy, use random_device almost as-is but make sure
            // values from rd() becomes seed_t's number of bits and unbiased
            // via sexmex.
            //
            // seed the generator
            for(; Begin != End; ++Begin) *Begin = sexmex<seed_t>(rd());
        }
    }
private:
    template<typename SeedType>
    inline void stir_buffer(std::vector<SeedType>& buf) const noexcept {
        for(size_t i = 0; i < buf.size() * 2; ++i) {
            buf[i % buf.size()] += static_cast<SeedType>(
                sexmex(buf[(i + buf.size() - 1) % buf.size()] + i));
        }
    }
};
//----------------------------------------------------------------------------------
struct shared_generator {
    // we want one instance shared between all instances of uniform_dist per thread
    static thread_local seeder ss;
    static thread_local std::mt19937 generator;
};
thread_local seeder shared_generator::ss{};
thread_local std::mt19937 shared_generator::generator(ss);
//----------------------------------------------------------------------------------
// a distribution template for uniform distributions, both int and real
template<typename T>
class uniform_dist : shared_generator {
public:
    uniform_dist(T low, T high) : distribution(low, high) {}
    // make instances callable
    inline T operator()() { return distribution(generator); }
private:
    template<class D>
    using dist_t =
        std::conditional_t<std::is_integral_v<D>, std::uniform_int_distribution<D>,
                           std::uniform_real_distribution<D>>;
    dist_t<T> distribution;
};
//----------------------------------------------------------------------------------
void thread_func() {
    uniform_dist<int> something(0, 10);
    for(int i = 0; i < 10; ++i) std::cout << something() << "n";
}
int main() {
    // all distributions sharing the same generator:
    uniform_dist<size_t> card_picker(0, 51);
    uniform_dist<int16_t> other(-32768, 32767);
    uniform_dist<float> fd(-1000.f, 1000.f);
    uniform_dist<double> dd(-1., 1.);
    for(int i = 0; i < 10; ++i) std::cout << card_picker() << "n";
    std::cout << "--n";
    for(int i = 0; i < 10; ++i) std::cout << other() << "n";
    std::cout << "--n";
    for(int i = 0; i < 10; ++i) std::cout << fd() << "n";
    std::cout << "--n";
    for(int i = 0; i < 10; ++i) std::cout << dd() << "n";
    // in the thread function, a new generator will be created and seeded.
    std::thread t(thread_func);
    t.join();
}