i = 1; j = 2;

1. Loads are not reordered with other loads.
2. Stores are not reordered with other stores.
3. Stores are not reordered with older loads.
4. Loads may be reordered with older stores to different locations but not with older
stores to the same location.

THE X86 MODEL.

The X86 has a relatively strong model. It states that all memory writes
can not pass one another. Bascially every write is a WriteMemoryBarrier.
What that means is that on the X86 the LazyInit example will never display
a problem. In particular on the X86 the
System.Threading.Thread.WriteMemoryBarrier() API is a no-op. On other
processors however it is important to have the barrier there.

CAVEATES for V1

Unfortunately, the MemoryBarrier APIs do not exist in the V1 product (they
were not a priority since V1 only supports the X86 and as we have seen,
code will work properly on the X86 without the MemoryBarrier calls.
These APIs have already been added what will be the next version of the
platform (to ship with Windows XP server). If you are concerned about
this issue, I would recommend you add the MemoryBarrier calls in the
correct places, and then comment them out until such time as you upgrade
to the next version of DOTNET.

Pzz>Довольно оскорбительная точка зрения

i = 1; j = 2;

2.1 Loads are not reordered with other loads and stores are not
reordered with other stores
Intel 64 memory ordering ensures that loads are seen in program order, and that stores are
seen in program order.
Processor 0                  Processor 1
mov [ _x], 1 // M1           mov r1,[_y] // M3
mov [ _y], 1 // M2           mov r2, [_x] // M4
Initially x == y == 0
r1 == 1 and r2 == 0 is not allowed

Intel 64 memory ordering allows load instructions to be reordered with prior stores to a
different location. However, loads are not reordered with prior stores to the same location.
The first example in this section illustrates the case in which a load may be reordered with an
older store – i.e. if the store and load are to different non-overlapping locations.

Processor 0                    Processor 1
mov [ _x], 1  // M1            mov [ _y], 1 // M3
mov r1, [ _y] // M2            mov r2, [_x] // M4

Initially x == y == 0
r1 == 0 and r2 == 0 is allowed

template <class TYPE>
class QueueMutex
{
public:
    QueueMutex(size_t heap_size);
    ~QueueMutex();

    void Enqueue(const TYPE& data);
    bool Dequeue(TYPE& data);

private:
    struct Element
    {
        TYPE data;
        Element* next;

        Element(const TYPE& _data) : data(_data), next(NULL) {}
    };

    Element * rqueue;
    volatile Element * whead, * wtail;
    Alloc<Element> heap;

    Mutex writer_cs;
};

template <class TYPE>
QueueMutex<TYPE>::QueueMutex(size_t heap_size)
: heap(heap_size)
{
    rqueue = NULL;
    whead = wtail = NULL;
}

template <class TYPE>
QueueMutex<TYPE>::~QueueMutex()
{
}

template <class TYPE>
void QueueMutex<TYPE>::Enqueue(const TYPE& data)
{
    Element * n = heap.alloc(data);

    writer_cs.lock();
    if (whead == NULL)
        whead = n;
    else
        wtail->next = n;
    writer_cs.unlock();
    // если писателей много это присвоение нужно внести в
    // критическую секцию
    wtail = n;
}

template <class TYPE>
bool QueueMutex<TYPE>::Dequeue(TYPE& data)
{
    Element * next = rqueue;
    if (next == NULL) {
        next = (Element *)whead;
        if (next == NULL)
            return false;
        writer_cs.lock();
        whead = NULL;
        writer_cs.unlock();
    }

    data = next->data;
    rqueue = next->next;
    heap.release(next);
    return true;
}

template <class TYPE> class LockFreeQueue
{
public:
    /// constructor
    LockFreeQueue();
    /// destructor
    ~LockFreeQueue();

    // Writer method
    void Enqueue(TYPE* data);

    // Flush remained data. Writer method
    bool Flush();

    // Reader method
    bool Dequeue(volatile TYPE*& data);

private:
    volatile TYPE *readerTop;
    volatile TYPE *tempTop;
    TYPE *writerTop, *writerBottom;
};

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
LockFreeQueue<TYPE>::LockFreeQueue()
{
    readerTop = tempTop = writerTop = writerBottom = NULL;
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
LockFreeQueue<TYPE>::~LockFreeQueue()
{
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
void
LockFreeQueue<TYPE>::Enqueue(TYPE* data)
{
    //n_assert(data);

    data->next = NULL;

    if (writerTop)
    {
        writerBottom->next = data;
        writerBottom = data;
    }
    else
    {
        writerTop = writerBottom = data;
    }

    if (!tempTop)
    {
        tempTop = writerTop;
        writerTop = NULL;
    }
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
bool
LockFreeQueue<TYPE>::Flush()
{
    if (!writerTop) return true;

    if (!tempTop)
    {
        tempTop = writerTop;
        return true;
    }
    return false;
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
bool
LockFreeQueue<TYPE>::Dequeue(volatile TYPE*& data)
{
    if (!readerTop)
    {
        if (tempTop)
        {
            readerTop = tempTop;
            tempTop   = NULL;
        }
        else
        {
            return false;
        }
    }

    data = readerTop;
    readerTop = readerTop->next;

    return true;
}