template <class TYPE> class QueueNoMutex
{
public:
    QueueNoMutex();
    ~QueueNoMutex();

    // Запись в очередь
    void Enqueue(const TYPE& data);

    // Сброс в промежуточный указатель, если пишущий поток завершился раньше.
    bool Flush();

    // Прочитать из очереди следующий елемент
    bool Dequeue(TYPE& data);

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

    void DeleteChain(Element* el);

    volatile bool isTempQueueSet;

    Element *readerTop;
    Element *tempTop;
    Element *writerTop, *writerBottom;
};

template<class TYPE>
QueueNoMutex<TYPE>::QueueNoMutex()
{
    readerTop = tempTop = writerTop = writerBottom = NULL;
    isTempQueueSet = false;
}

template<class TYPE>
QueueNoMutex<TYPE>::~QueueNoMutex()
{
    DeleteChain(readerTop);
    DeleteChain(tempTop);
    DeleteChain(writerTop);
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
void
QueueNoMutex<TYPE>::Enqueue(const TYPE& data)
{
    // создаем новый елемент цепочки и помещаем в него данные
    Element* el = new Element;
    el->data = data;
    el->next = NULL;

    // если цепочка сообщений для записи не пуста, добавляем елемент в ее конец
    if (writerTop)
    {
        writerBottom->next = el;
        writerBottom = el;
    }
    else
    {
        // иначе это будет первый елемент цепочки
        writerTop = writerBottom = el;
    }

    // проверяем свободна ли промежуточная цепочка
    if (!isTempQueueSet)
    {
        // перекидываем в нее цепочку записи
        tempTop = writerTop;
        // освобождаем указатель вершины цепочки записи
        writerTop = NULL;
        // и устанавливаем флаг готовности промежуточной цепочки
        isTempQueueSet = true;
    }
}

template<class TYPE>
bool
QueueNoMutex<TYPE>::Flush()
{
    // если цепочка записи пуста, возвращаем успешность сброса
    if (!writerTop) return true;

    // проверяем свободна ли промежуточная цепочка
    if (!isTempQueueSet)
    {
        // перекидываем в нее цепочку записи
        tempTop = writerTop;
        // освобождаем указатель вершины цепочки записи
        writerTop = NULL;
        // и устанавливаем флаг готовности промежуточной цепочки
        isTempQueueSet = true;

        // возвращаем успешность сброса
        return true;
    }

    // цепочка все еще не сброшена
    return false;
}

template<class TYPE>
bool
QueueNoMutex<TYPE>::Dequeue(TYPE& data)
{
    // если цепочка для чтения пуста
    if (!readerTop)
    {
        // проверяем, есть ли данные в промежуточной цепочке
        if (isTempQueueSet)
        {
            // перебрасываем промежуточную цепочку в цепочку для чтения
            readerTop = tempTop;
            // обнуляем промежуточную цепочку (если используется Flush(), то не нужно)
            tempTop = NULL;
            // сообщаем, что промежуточная цепочка пуста
            isTempQueueSet = false;
        }
        else
        {
            // нет данных для чтения
            return false;
        }
    }

    // вычитываем данные из верхнего елемента цепочки
    data = readerTop->data;

    // удаляем и смещаем вершину цепочки для чтения
    Element* cur = readerTop;
    readerTop = cur->next;
    delete cur;

    return true;
}

template<class TYPE>
void
QueueNoMutex<TYPE>::DeleteChain(Element* el)
{
    while (el)
    {
        Element* cur = el;
        el = cur->next;
        delete cur;
    }
}

typedef QueueNoMutex<int> MyQueue;

class WriterThread: public Thread
{
public:
    void DoWork()
    {
        int data = 100;

        // основной цикл
        while (data >= 0)
        {
            queue->Enqueue(data--);

            // эмуляция работы реального потока
            Sleep(100);
        }

        // подчищаем хвосты, если последняя запись не перебросила в промежуточную цепочку
        while (!queue->Flush())
        {
            Sleep(100);
        }
    }

    // ...

private:
    MyQueue* queue;
};

class ReaderThread: public Thread
{
public:
    void DoWork()
    {
        int curVal = 1, data = 1;
        bool found = false;

        // основной цикл чтения
        while (data > 0)
        {
            while (queue->Dequeue(data))
            {
            if (curVal != data)
        {
            printf("%d != %d\n", curVal, data);
        }
        curVal = data - 1;
                found = true;
            }

            if (found)
            {
        printf("Last read: %d\n", data);
                found = false;
            }

            // эмуляция работы реального потока
            Sleep(200);
        }
        printf("Done.\n");
    }

    // ...

private:
    MyQueue* queue;
};

Some processor architectures, such as the Intel Itanium, IBM POWER and PowerPC,
and Alpha processors, have weak memory consistency, in which memory operations
on different addresses may be reordered by the hardware for the sake of efficiency.
[skip]
If you are programming only IA-32 and Intel 64/AMD64 processor platforms,
you can skip this section. These platforms have the strongest memory consistency
models.

Some processor architectures, such as the Intel Itanium, IBM POWER and PowerPC,
and Alpha processors, have weak memory consistency, in which memory operations
on different addresses may be reordered by the hardware for the sake of efficiency.
[skip]
If you are programming only IA-32 and Intel 64/AMD64 processor platforms,
you can skip this section. These platforms have the strongest memory consistency
models.

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;
}

На однопроцессорной машине она может быть лучше более чем на порядок.
На многопроцессорной машине выигрыш будет ещё существеннее + иметь
последствия не только на голую скорость, но и на масштабиремость.

class Mutex
{
public:

    Mutex();
    ~Mutex();

    bool try_lock();
    void lock();
    void unlock();

private:
    DWORD  owner;
    DWORD  count;
    HANDLE hwait;
    volatile LONG   avail;
};

Mutex::Mutex()
{
    owner = 0;
    count = 0;
    avail = 1;
    hwait = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
}

Mutex::~Mutex()
{
    CloseHandle(hwait);
}

bool Mutex::try_lock()
{
    DWORD cur = GetCurrentThreadId();

    if (owner != cur) {
        LONG p = CAS(&avail, 0, -1);
        if (p != 0)
            return false;
        owner = cur;
    }
    count++;
    return true;
}

void Mutex::lock()
{
    DWORD cur = GetCurrentThreadId();

    if (owner != cur) {
        LONG p = InterlockedDecrement(&avail);
        if (p < 0) {
            WaitForSingleObject(hwait, INFINITE);
        }
        owner = cur;
    }
    count++;
}

void Mutex::unlock()
{
    if (--count == 0) {
        owner = 0;
        if (InterlockedIncrement(&avail) < 1) {
            ReleaseSemaphore(hwait, 1, NULL);
        }
    }
}

#define LOCK_FREE_QUEUE2_USE_FLUSH 1

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

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

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

#if LOCK_FREE_QUEUE2_USE_FLUSH
    // Flush remained data. Writer method
    bool Flush();
#else
    // Inform that writer queue finished
    void SetWriterFinished();
#endif

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

#if LOCK_FREE_QUEUE2_USE_FLUSH == 0
    volatile bool isWriterFinished;
#endif
};

template<class TYPE>
LockFreeQueue2<TYPE>::LockFreeQueue2()
{
    readerTop = writerTop = writerBottom = NULL;

#if LOCK_FREE_QUEUE2_USE_FLUSH == 0
    isWriterFinished = false;
#endif
}

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

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

    data->next = NULL;

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

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

template<class TYPE>
bool
LockFreeQueue2<TYPE>::Dequeue(volatile TYPE*& data)
{
    if (!readerTop)
    {
#if LOCK_FREE_QUEUE2_USE_FLUSH == 0
        if (isWriterFinished && writerTop)
        {
            readerTop = writerTop;
            writerTop = NULL;
        }
        else
#endif
        {
            return false;
        }
    }

    data = readerTop;
    readerTop = readerTop->next;

    return true;
}

#if LOCK_FREE_QUEUE2_USE_FLUSH
template<class TYPE>
bool
LockFreeQueue2<TYPE>::Flush()
{
    if (!writerTop) return true;

    if (!readerTop)
    {
        readerTop = writerTop;
        return true;
    }
    return false;
}
#else
template<class TYPE>
void
LockFreeQueue2<TYPE>::SetWriterFinished()
{
    isWriterFinished = true;
}
#endif

class Mutex
{
public:
    Mutex();
    ~Mutex() {}

    void lock();
    bool try_lock();
    void unlock();

    static void attach_thread();
private:

    struct mqitem
    {
        volatile struct mqitem * next;
        HANDLE hwait;
    } e, *queue;

#ifdef RECURSIVE_MUTEX
    volatile DWORD owner;
    DWORD count;
#endif

    static _declspec(thread) mqitem * thread_item;
};

_declspec(thread) Mutex::mqitem * Mutex::thread_item = NULL;

void Mutex::attach_thread()
{
    if (thread_item == NULL) {
        thread_item = new mqitem;
        thread_item->hwait = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
    }
}

Mutex::Mutex()
{
    e.next = NULL;
    queue = &e;
#ifdef RECURSIVE_MUTEX
    owner = 0;
    count = 0;
#endif
}

void Mutex::lock()
{
    mqitem * p, * h;
    DWORD cur = GetCurrentThreadId();

#ifdef RECURSIVE_MUTEX
    if (owner != cur) {
#endif
        assert( thread_item != NULL );
        p = thread_item;

        do {
            h = (mqitem *)e.next;
            p->next = h;
        } while( _CAS_PTR((PVOID*)&e.next, (PVOID)h, (PVOID)p) != h );

        if (h != NULL)
            WaitForSingleObject(thread_item->hwait, INFINITE);

#ifdef RECURSIVE_MUTEX
#ifdef _DEBUG
        assert(CAS(&owner, (DWORD)NULL, cur) == NULL);
#else
        owner = cur;
#endif
    }
    count++;
#endif
}

bool Mutex::try_lock()
{
    mqitem * p;
    DWORD cur = GetCurrentThreadId();

#ifdef RECURSIVE_MUTEX
    if (owner != cur) {
#endif
        assert( thread_item != NULL );
        if (e.next != NULL)
            return false;

        p = thread_item;
        p->next = NULL;

        if ( _CAS_PTR((PVOID*)&e.next, (PVOID)NULL, (PVOID)p) != NULL )
            return false;

#ifdef RECURSIVE_MUTEX
#ifdef _DEBUG
        assert(CAS(&owner, (DWORD)NULL, cur) == NULL);
#else
        owner = cur;
#endif
    }
    count++;
#endif
    return true;
}

void Mutex::unlock()
{
    mqitem * o = thread_item;
    volatile mqitem * p = queue;

#ifdef RECURSIVE_MUTEX
    assert(owner == GetCurrentThreadId());
    if (--count == 0) {
#endif
        /* we'd better not to have high concurrency on this mutex */
        while(p->next != o)
            p = p->next;

#ifdef RECURSIVE_MUTEX
        owner = NULL;
#endif
        if (p != &e)
            ReleaseSemaphore(p->hwait, 1, NULL);
        p->next = NULL;
#ifdef RECURSIVE_MUTEX
    }
#endif
}

class Mutex
{
public:
    Mutex();
    ~Mutex() {}

    void lock();
    bool try_lock();
    void unlock();

    static void attach_thread();
private:

    struct mqitem
    {
        volatile struct mqitem * next;
        struct mqitem * prior;
        HANDLE hwait;
    } e, * tail;

#ifdef RECURSIVE_MUTEX
    volatile DWORD owner;
    DWORD count;
#endif

    static _declspec(thread) mqitem * thread_item;
};

_declspec(thread) Mutex::mqitem * Mutex::thread_item = NULL;

void Mutex::attach_thread()
{
    if (thread_item == NULL) {
        thread_item = new mqitem;
        thread_item->hwait = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
    }
}

Mutex::Mutex()
{
    e.next = NULL;
    tail = NULL;
#ifdef RECURSIVE_MUTEX
    owner = 0;
    count = 0;
#endif
}

void Mutex::lock()
{
    mqitem * p, * h;
    DWORD cur = GetCurrentThreadId();

#ifdef RECURSIVE_MUTEX
    if (owner != cur) {
#endif
        assert( thread_item != NULL );
        p = thread_item;
        p->prior = NULL;

        do {
            h = (mqitem *)e.next;
            p->next = h;
        } while( _CAS_PTR((PVOID*)&e.next, (PVOID)h, (PVOID)p) != h );

        if (h != NULL)
            WaitForSingleObject(thread_item->hwait, INFINITE);

#ifdef RECURSIVE_MUTEX
#ifdef _DEBUG
        assert(CAS(&owner, (DWORD)NULL, cur) == NULL);
#else
        owner = cur;
#endif
    }
    count++;
#endif
}

bool Mutex::try_lock()
{
    mqitem * p;
    DWORD cur = GetCurrentThreadId();

#ifdef RECURSIVE_MUTEX
    if (owner != cur) {
#endif
        assert( thread_item != NULL );
        if (e.next != NULL)
            return false;

        p = thread_item;
        p->next = NULL;

        if ( _CAS_PTR((PVOID*)&e.next, (PVOID)NULL, (PVOID)p) != NULL )
            return false;

#ifdef RECURSIVE_MUTEX
#ifdef _DEBUG
        assert(CAS(&owner, (DWORD)NULL, cur) == NULL);
#else
        owner = cur;
#endif
    }
    count++;
#endif
    return true;
}

void Mutex::unlock()
{
    mqitem * o = thread_item;
    mqitem * p = &e;

#ifdef RECURSIVE_MUTEX
    assert(owner == GetCurrentThreadId());
    if (--count == 0) {
#endif
        /* we know the tail sometimes */
        if (tail != &e) {
            p = tail;
            tail = p->prior;
        } else {
            /* scan the list to find the tail and update
             * the list inverse. Anyway, if the unlock() time
             * is sensetive, do not use in highly concurrent
             * conditions
             */
            while(p->next != o) {
                p->next->prior = p;
                p = (mqitem *)p->next;
            }
            tail = p->prior;
        }

#ifdef RECURSIVE_MUTEX
        owner = NULL;
#endif
        if (p != &e)
            ReleaseSemaphore(p->hwait, 1, NULL);

        p->next = NULL;
#ifdef RECURSIVE_MUTEX
    }
#endif
}

    /* we'd better not to have high concurrency on this mutex */
    while(p->next != o)
        p = p->next;

void Mutex::lock()
{
    mqitem* p = thread_item;
    mqitem* h;
    do 
    {
        h = (mqitem *)e.next;
        p->next = h;
    } while( _CAS_PTR((PVOID*)&e.next, (PVOID)h, (PVOID)p) != h );

    if (p->next)
        p->next->prev = p;

    if (h != NULL)
        WaitForSingleObject(thread_item->hwait, INFINITE);
}

void Mutex::unlock()
{
    mqitem * o = thread_item;
    volatile mqitem * p = queue;

    if (o->prev->next == o)
    {
        // we're lucky
        p = o->prev;
    }
    else
    {
        // back-off
        while(p->next != o)
            p = p->next;
    }

    if (p != &e)
        ReleaseSemaphore(p->hwait, 1, NULL);
    p->next = NULL;
}

class Mutex
{
public:
    Mutex();
    ~Mutex() {}

    void lock();
    void unlock();

    static void attach_thread();
private:
    enum State { UNCERTAIN, WAITING, RUN };

    struct mqitem
    {
        Mutex * waiting;

        volatile struct mqitem * next;
        struct mqitem * prior;
        State state;
        HANDLE hwait;
    } e;

    static _declspec(thread) mqitem * thread_item;
};

_declspec(thread) Mutex::mqitem * Mutex::thread_item = NULL;

void Mutex::attach_thread()
{
    if (thread_item == NULL) {
        thread_item = new mqitem;
        thread_item->hwait = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
    }
}

Mutex::Mutex()
{
    e.next = NULL;
    e.state = RUN;
    e.waiting = NULL;
}

void Mutex::lock()
{
    mqitem * p, * h;

    assert( thread_item != NULL );
    p = thread_item;
    p->prior = &e;

    do {
        h = (mqitem *)e.next;
        p->next = h;
        p->state = UNCERTAIN;
        p->waiting = this;
    } while( _CAS_PTR((PVOID*)&e.next, (PVOID)h, (PVOID)p) != h );

    /* hint the previous item. And you'd better not to release the other
thread's
     * descriptor ;-)
     */
    if (h)
        h->prior = h;

    while (p->next != NULL) {
        p->state = WAITING;
        WaitForSingleObject(p->hwait, INFINITE);
    }
    p->state = RUN;
}

void Mutex::unlock()
{
    mqitem * o = thread_item;
    mqitem * p;
    BOOL rescan;

    /* check the hint */
    p = o->prior;
    if (p->next != o) {
        /* Scan the whole list, updating the hints 'prior' as well. */
        p = &e;
        while(p->next != o) {
            p->next->prior = p;
            p = (mqitem *)p->next;
        }
    }

    /* we might have to rescan the queue if no waiters yet */
    rescan = (e.next == thread_item);

    /* release the mutex */
    p->next = NULL;

    /* Now to prevent race conditions we have to rescan the list to see
     * if any other thread has appeared since we released the lock in
     * the previous line.
     * Note that we have to deal with two threads only.
     */

    if (rescan) {
    /* we could have updated 'prior' hints here, should we? */
        for(p = &e; p->next != NULL; p = (mqitem *)p->next)
            ;
    }

    if (p->waiting == this) {
        /* spin until thread decided about it's state.
         * Removing this would just cause spurious wakeups.
         */
        while (p->state == UNCERTAIN)
            ;

        if (p->state != RUN)
            ReleaseSemaphore(p->hwait, 1, NULL);
    }
}

lock()
{
    /* barrier */
    if (!free) {
        wait = true;
        Wait();
    }
    free = false;
}

unlock()
{
    free = true;
    /* barrier */
    if (wait) {
        wait = false;
        Signal();
    }
}

lock()
{
    /* barrier */
    if (wait > 0 && free) {
        wait++;
        Signal();
        Wait();
        wait--;
    } else if (!free) {
        wait++;
        Wait();
        wait--;
    }
    free = false;
}

unlock()
{
    /* no-barrier */
    if (wait > 0)
        Signal();
    free = true;
}

struct mutex
{
    long requested;  /* количество запросов на блокировки */
    long granted;    /* количество выданных блокировок    */
    long sent;       /* количество посланных сигналов     */
    long got;        /* количество полученных сигналов    */
};

void
init(mutex * m)
{
    m->granted = 0;
    m->requested = 0;
    m->sent = 0;
    m->got  = 0;
}

void
lock(mutex * m)
{
    long mine;
    int  j;

    /* InterlockedIncrement включает в себя барьер */
    mine = InterlockedIncrement(&m->requested) - 1L;
    while (m->granted != mine) {
        for(j = 0; j < WAIT_COUNT; j++) {
            if (m->granted == mine)
                return;
        }
        Wait(m, INFINITE);
    m->got++;
    }
}

void
unlock(mutex * m)
{
    if (m->requested != ++m->granted && m->sent == m->got) {
    m->sent++;
        Signal(m);
    }
}