As i have made the flag volatile at some point it value of flag should change. But it is waiting infinitely on t thread only

Question

#include <iostream>
#include<thread>
#include <initializer_list>
#include <vector>
#include <future>
#include <time.h>
using namespace std;
class Gadget{
public:
    Gadget(){
        flag_ = false;
        cout<<"Creating new Gadgets"<<endl;
    }
    void wait(){
        while(flag_==false){
            cout<<"waiting here...."<<endl;
            this_thread::sleep_for(chrono::milliseconds(1000));
        }
    }
    void wake(){
        flag_ = true;
    }
private:
    volatile bool flag_;
};

I am trying to make two threads and one thread will sleep for 1 sec after checking the flag value. As i have made flag volatile it should change at some point. But the program is waiting infinitely.

int main() {
    Gadget g;
    thread t(&Gadget::wait,g);
    thread s(&Gadget::wake,g);
    t.join();
    s.join();
    cout<<"Ending the program "<<endl;
    return 0;
}

Answer 1

volatile isn't for variables that are changed by the program itself. It's for variables that changes outside the program's control - like if it's directly connected to hardware.

Your main problem is however that you pass g by value so the two threads are working on different copies of your original g.

So, change to

    std::atomic<bool> flag_;

and

    thread t(&Gadget::wait, &g);
    thread s(&Gadget::wake, &g);

Also worth mentioning: The two methods will not necessarily run in the order you start them, so waiting here.... may or may not show up.

---

Edit:

As mentioned in the comments: When waiting for a condition you should usually use a std::condition_variable. I've made an example of how that could look. I've also moved the starting of the threads into Gadget which makes it more obvious which object the thread is working on.

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

class Gadget {
public:
    Gadget() { std::cout << "Creating new Gadget\n"; }

    // new interface for starting threads
    std::thread start_wait() { return std::thread(&Gadget::wait, this); }
    std::thread start_wake() { return std::thread(&Gadget::wake, this); }

private:
    void wait() {
        std::unique_lock<std::mutex> ul(mutex_);
        std::cout << "wait: waiting here...\n";

        // Read about "spurious wakeup" to understand the below:
        while(not flag_) cond_.wait(ul);
        // or:
        // cond_.wait(ul, [this] { return flag_; });

        std::cout << "wait: done\n";
    }

    void wake() {
        // simulate some work being done for awhile
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));

        { // lock context start
            std::lock_guard<std::mutex> lg(mutex_);
            flag_ = true;
            std::cout << "wake: notifying the waiting threads\n";
        } // lock context end

        // notify all waiting threads
        cond_.notify_all();
    }

    std::condition_variable cond_;
    std::mutex mutex_;
    bool flag_ = false; // now guarded by a mutex instead
};

int main() {
    Gadget g;

    // start some waiting threads
    std::vector<std::thread> threads(16);
    for(auto& th : threads) th = g.start_wait();

    // and one that wakes them up
    auto th_wake = g.start_wake();

    for(auto& th : threads) th.join();
    th_wake.join();

    std::cout << "Ending the program\n";
}