FairLock fLock;

T sharedData;

std::vector<int> ids { std::vector<int>(MAX) }; // TODO

std::atomic<size_t> it {0};

size_t count {0};

void Write(int id) {

// There is not any guarantee that the threads are actually created with

// equivalent latency. So they will arrive here in arbitrary order.

// This code is actually simple.

// We atomically store the id order of arriving before the lock

// (unprotected, but atomically). And then we check that the same order

// is respected in the lock take (inside the lock).

ids[it++] = id;

fLock.Lock();

T readed = sharedData;

sharedData = id;

std::cout << "Writer " << id

<< " readed " << readed

<< " and wrote : " << sharedData << std::endl;

if (count > 0)

myassert(readed == ids[count++]);

std::this_thread::sleep_for(std::chrono::milliseconds(10));

fLock.Unlock();

}

operator T() const

{

return sharedData;

}

argparser::init(argc, argv);

const size_t nWriters = argparser::cl<size_t>("Writers");

// The track vector has a limit that needs to be specified and we cannot

// exceed.

myassert(nWriters < 100);

ProtectedData<100> data;

std::vector<std::thread> writers;

for (size_t i = 0; i < nWriters; ++i) {

writers.emplace_back(&ProtectedData<100>::Write, &data, i);

}

std::cout << "All threads created" << std::endl;

for (std::thread& writer : writers)

writer.join();

std::cout << "Final value: " << data << std::endl;

return 0;