foo.cpp

#include <iostream>                                                                              
#include <thread>                                                                               
#include <mutex>                                                                
#include <chrono>                                                               
#include <atomic>

using std::mutex;
using std::unique_lock;
using namespace std::chrono;
using std::cout;
using std::endl;

mutex mtx;

std::atomic<uint64_t> count;

int i = 0;                       // shared value by producers and consumers

void t1() { 
                while (i < 1000) 
                                std::this_thread::sleep_for(milliseconds(1));
                count +=5;
}


void t2() {
                high_resolution_clock::time_point t1 = high_resolution_clock::now();
                while (i < 10000 ) {
                                count++;
                                unique_lock<mutex> lck(mtx);
                                i++;
                                lck.unlock();
                }
                high_resolution_clock::time_point t2 = high_resolution_clock::now();
                nanoseconds dtn(t2-t1);
                cout << dtn.count() << endl;
}

int main () {
                std::thread first(t1);
                std::thread second(t2);

                first.join();
                second.join();

                cout << count << endl;

                return 0;
}