将两个线程同步到同一计时器

Question

I have the following scenario:

int main(){
    data_t data;
    std::thread data_producer([&data](){
        while(true){
            data = produce_data();
            std::this_thread::sleep_for(1s);
        }
    }); 

    auto print_data = [&data](){
        std::cout << data.as_string() << "\n";
    });

    print_data();
    //do some stuff
    print_data();
    print_data();
    //do some stuff
    print_data();
    //.....
}

As you see, the data producer runs forever, trying to produce data and overwrite the old one each time.

When I call print_data() , the last produced data would be printed out. However, if print_data was faster than the data_producer , the same data will be printed twice.

How can I prevent this behavior? In other words, I want print_data() to be blocked until there is a new data from producer.

On the other hand, I do not mind if a data was produced and no one printed it. But I mind if the produced date was printed more than once?

I tried to use std::condition_variable with std::mutex . I came up with this solution. I tested it on some scenarios and it was working but I am not sure if it is correct:

int main(){
    std::mutex m;
    std::condition_variable cv;
    bool ready{ false };
    data_t data;
    std::thread data_producer([&data](){
        while(true){                
            {
                std::lock_guard<std::mutex> lk(m);
                data = produce_data();
                ready = true;
            }
            cv.notify_one()
            std::this_thread::sleep_for(1s);
        }
    }); 

    auto print_data = [&data](){
        std::unique_lock<std::mutex> lk(m);
        cv.wait(lk, [&]{return ready;});
        std::cout << data.as_string() << "\n";
        ready = false;
    });

    print_data();
    //do some stuff
    print_data();
    print_data();
    //do some stuff
    print_data();
    //.....
}

Although it worked as I expected in the tests I did, I highly suspect that my solution is rubbish.

Is it the right way?

Answer 1

There's a bunch of issues here with the code as given.

The way you're accessing data lends itself to concurrency issues. You need to protect the variables reads and writes via a lock. It seems to be a structure on the stack. But as given, you run the risk of (1) seeing stale values in the reader because the CPU running the reader doesn't have an up to date view of what the writer has done (this is a visibility issue) (2) see incomplete or strange values of date because the writer was stopped in the middle of an update. If data is a large struct this is doubly true as the copy is more likely to be interrupted rather than a just a pointer write, which is atomic by itself. But you could end up seeing an incomplete object from construction (see safe initialization and publication for more details).

For your main problem, you either need to keep tabs on what has been published by the producer. You could have a counter which gets incremented every time new data is published. The reader also stores the counter of the last data which it printed, and will only print data when the current counter is higher.

The code might look like this in pseudocode:

mutex lock;
int counter = 0;
data_t data = null;
int last_saw = -1;

\\ in writer
   data_t new_data = produce_data;
   lock.acquire();
   counter++;
   data = new_data;
   lock.release();
\\ in reader
   data_t to_print = null;
   lock.acquire();
   if (counter > lastSaw) {
       to_print = data;
       last_saw = counter;
   }
   lock.release();
   if (to_print != null)
       count << to_print << endl;