测试环形缓冲区实现的"cache not flushed to main memory"

upd以反映最近的建议，使curWriteNum不稳定，用std::cout重新排列pool.Commit();

我创建了一个读写器环缓冲区(示例中的类ArrayPool)。我喜欢它，但我担心当一个(读取器)线程因为另一个线程在另一个CPU上运行并使用另一个缓存或类似的东西而没有看到新值时，我会遇到问题。

我已经创建了测试程序。它创建了100个线程，所以我认为它们必须或多或少地分布在所有可用的处理器上。

#include <stdint.h>
#include <iostream>
#include <boost/thread.hpp>
#include <chrono>
#include <thread>
template<class T> class ArrayPool
{
public:
ArrayPool() {
};
~ArrayPool(void) {
};
bool IsEmpty() {
return curReadNum == curWriteNum;
}
T* TryGet()
{
if (curReadNum == curWriteNum)
{
return NULL;
}
T* result = &storage[curReadNum & MASK];
++curReadNum;
return result;
}
T* Obtain() {
return &storage[curWriteNum & MASK];
}
void Commit()
{
++curWriteNum;
if (curWriteNum - curReadNum > length)
{
std::cout <<
"ArrayPool curWriteNum - curReadNum > length! " <<
curWriteNum << " - " << curReadNum << " > " << length << std::endl;
}
}
private:
static const uint32_t length = 65536;
static const uint32_t MASK = length - 1;
T storage[length];
volatile uint32_t curWriteNum;
uint32_t curReadNum;
};
struct myStruct {
int value;
};
ArrayPool<myStruct> pool;
void ReadThread() {
myStruct* entry;
while(true) {
while ((entry = pool.TryGet()) != NULL) {
std::cout << entry->value << std::endl;
}
}
}
void WriteThread(int id) {
std::chrono::milliseconds dura(1000 * id);
std::this_thread::sleep_for(dura);
myStruct* storage = pool.Obtain();
storage->value = id;
pool.Commit();
std::cout << "Commited value! " << id << std::endl;
}

int main( void )
{
boost::thread readThread = boost::thread(&ReadThread);
boost::thread writeThread;
for (int i = 0; i < 100; i++) {
writeThread = boost::thread(&WriteThread, i);
}
writeThread.join();
return 0;
}

我试着在2*Xeon E5服务器上运行这个程序，一切都很好，每个值都被捕获了：

...
Commited value! 19
19
Commited value! 20
20
Commited value! 21
21
Commited value! 22
22
Commited value! 23
23
Commited value! 24
24
Commited value! 25
25
Commited value! 26
26
....

同样在Process Explorer中，我可以看到线程数是如何从~101减少到1的。这是否意味着我的ArrayPool类很好，在现代英特尔处理器上不可能面临任何此类问题？如果有可能重现"缓存"的问题，那么该怎么做呢？