#ifndef LOCKER_H
#define LOCKER_H

template<int magic>
class Locker
{
public:
    Locker(bool write) 
    {
        init();

        m_write = write;

        if (!m_write)
        {
            WaitForSingleObject(mutex, INFINITE);

            if (!readers)
            {
                ResetEvent(event);
            }

            InterlockedIncrement(&readers);

            ReleaseMutex(mutex);
        }
        else
        {
            HANDLE h[] = {event, mutex};

            WaitForMultipleObjects(2, h, TRUE, INFINITE);
        }
    }

    ~Locker() 
    {
        WaitForSingleObject(mutex, INFINITE);

        if (!m_write)
        {
            InterlockedDecrement(&readers);

            if (!readers)
            {
                SetEvent(event);
            }
        }
        else
        {
            ReleaseMutex(mutex);
        }

        ReleaseMutex(mutex);
    };

private:

    void init()
    {
        if (!first) return;
        first = false;
        mutex = CreateMutex(NULL, FALSE, NULL);
        event = CreateEvent(NULL, TRUE, TRUE, NULL);
    }

    static bool   first;
    static HANDLE mutex;
    static HANDLE event;
    static LONG   readers;

    bool m_write;
};

template<int magic>
bool Locker<magic>::first = true;

template<int magic>
HANDLE Locker<magic>::mutex = NULL;

template<int magic>
HANDLE Locker<magic>::event = NULL;

template<int magic>
LONG Locker<magic>::readers = 0;

#endif //LOCKER_H

typedef Locker<123> Resource1Locker;
typedef Locker<456> Resource2Locker;

.....

void func1()
{
    Resource1Locker lock(false);
    // теперь первый ресурс можно безболезненно читать, его не изменят до конца функции
}

void func2()
{
    Resource2Locker lock(true);
    // теперь второй ресурс можно безболезненно изменять, его не будут читать до конца функции
}

...
SH>        else
SH>        {
SH>            HANDLE h[] = {event, mutex};

SH>            WaitForMultipleObjects(2, h, TRUE, INFINITE);
SH>        }
SH>    }
SH>

SH>    ~Locker() 
SH>    {
SH>        WaitForSingleObject(mutex, INFINITE);

SH>        if (!m_write)
SH>        {
SH>            InterlockedDecrement(&readers);

SH>            if (!readers)
SH>            {
SH>                SetEvent(event);
SH>            }
SH>        }
SH>        else
SH>        {
SH>            ReleaseMutex(mutex);
SH>        }

SH>        ReleaseMutex(mutex);
SH>    };
...
SH>

//Запись данных
WaitForMultipleObjects(hRead,hWrite);
...        //пишем                
ReleaseMutex(hWrite);                

//Чтение данных
WaitForSingleObject(hWrite);
ResetEvent(hRead);                    
ReleaseMotex(hWrite);                    
...        //читаем
SetEvent(hRead);

void func()
{
    // длительное...
    {
         // и здесь длительное...
         SomeLoker lock(false);
         // обращаемся к ресурсу...
    }
    // опять длительное...
}

class CriticalSection
{
    friend class WorkWithCriticalSection;
    CRITICAL_SECTION h;
public:
    CriticalSection()
    {
        InitializeCriticalSection(&h);
    }
    ~CriticalSection()
    {
        DeleteCriticalSection(&h);
    }
};

class WorkWithCriticalSection
{
    CriticalSection* cs;
public:
    WorkWithCriticalSection(CriticalSection* acs)
    {
        cs = acs;
        EnterCriticalSection(&cs->h); 
    }
    ~WorkWithCriticalSection()
    {
        LeaveCriticalSection(&cs->h);
    }
};

CriticalSection cs;

void some_impotant_function()
{
WorkWithCriticalSection o(&cs);
...
ресурс заблокирован
...
}

void some_critical_function()
{
WorkWithCriticalSection o(&cs);
...
ресурс заблокирован
...
}