C++ 随机 uniform_int_distribution 在所有线程中返回相同的值

Question

I have the following code, I need to have a random number in given interval. Seems to work how I need.

   std::default_random_engine eng;
     std::uniform_int_distribution<int> dist(3, 7);
     int timeout = dist(eng);

But then I run it in different threads and repeated in the loop.

    std::default_random_engine defRandEng(std::this_thread::get_id());
    std::uniform_int_distribution<int> dist(3, 7);
    int timeout; // if I put timeout = dist(defRandEng); here it's all the same

    while (true)
    {
        timeout = dist(defRandEng);
        std::cout<<"Thread "<<std::this_thread::get_id()<<" timeout = "<<timeout<<std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(timeout));
}

But for every iteration in all threads the values are the same

Thread 139779167999744 timeout = 6
Thread 139779134428928 timeout = 6
Thread 139779067287296 timeout = 6
Thread 139779117643520 timeout = 6
Thread 139779100858112 timeout = 6
Thread 139779084072704 timeout = 6
Thread 139779151214336 timeout = 6
Thread 139779050501888 timeout = 6
Thread 139779033716480 timeout = 6

next interation

Thread 139779167999744 timeout = 4
Thread 139779151214336 timeout = 4
Thread 139779134428928 timeout = 4
Thread 139779117643520 timeout = 4
Thread 139779100858112 timeout = 4
Thread 139779084072704 timeout = 4
Thread 139779067287296 timeout = 4
Thread 139779050501888 timeout = 4
Thread 139779033716480 timeout = 4

Answer 1

You need to provide a seed based on some naturally random value to your random engine. The below example, that was adopted from your code snippets, works fine with 3 threads:

std::mutex lock;

void sample_time_out()
{
   std::stringstream ss;
   ss << std::this_thread::get_id();
   uint64_t thread_id = std::stoull(ss.str());

   std::default_random_engine eng(thread_id);
   std::uniform_int_distribution<int> dis(3, 7);


   for (int i = 0; i < 3; i++)
   {
      auto timeout = dis(eng);

      std::this_thread::sleep_for(std::chrono::seconds(timeout));
      {
         std::unique_lock<std::mutex> lock1(lock);
         std::cout << "Thread " << std::this_thread::get_id() << " timeout = " << timeout << std::endl;
      }
   }
}

int main()
{
   std::thread t1(sample_time_out);
   std::thread t2(sample_time_out);
   std::thread t3(sample_time_out);

   t1.join();
   t2.join();
   t3.join();

   return 0;
}

And the output of my first run is:

Thread 31420 timeout = 3
Thread 18616 timeout = 6
Thread 31556 timeout = 7
Thread 31420 timeout = 4
Thread 18616 timeout = 7
Thread 31420 timeout = 6
Thread 31556 timeout = 7
Thread 18616 timeout = 4
Thread 31556 timeout = 7