Семафоры

#include <Windows.h>
#include <stdio.h>
 
// количество клиентов
const int cMaxCount = 6;
 
// общий буфер
char g_chSharedBuffer[256] = { 0 };
 
//-------------------------------------------------------------------------------------------------
// RW-блокировка с приоритетом записи
//-------------------------------------------------------------------------------------------------
class CLockRW
{
protected:
    HANDLE m_hExclusive;
    HANDLE m_hReadCounter;
 
public:
    CLockRW()
    {
        m_hExclusive = CreateSemaphore(0, 1, 1, TEXT("rwExclusive"));
        m_hReadCounter = CreateSemaphore(0, cMaxCount, cMaxCount, TEXT("rwReadCounter"));
    }
 
    ~CLockRW()
    {
        CloseHandle(m_hReadCounter);
        CloseHandle(m_hExclusive);
    }
 
    void Lock(bool bWrite)
    {
        WaitForSingleObject(m_hExclusive, INFINITE);
        if (bWrite)
        {
            for (int i=0; i<cMaxCount; i++)
                WaitForSingleObject(m_hReadCounter, INFINITE);
        }
        else
        {
            WaitForSingleObject(m_hReadCounter, INFINITE);
        }
        ReleaseSemaphore(m_hExclusive, 1, 0);
    }
 
    void Unlock(bool bWrite)
    {
        ReleaseSemaphore(m_hReadCounter, (bWrite) ? cMaxCount : 1, 0);
    }
};
 
//-------------------------------------------------------------------------------------------------
// отладочная печать в консоль
//-------------------------------------------------------------------------------------------------
void log(const char* msg, ...)
{
    static HANDLE _log = CreateMutex(0, FALSE, 0);
    WaitForSingleObject(_log, INFINITE);
 
    SYSTEMTIME st;
    GetSystemTime(&st);
    printf("%02d:%02d:%02d> <%d> ", st.wHour, st.wMinute, st.wSecond, GetCurrentThreadId());
 
    va_list vl;
    va_start(vl, msg);
    vprintf(msg, vl);
    va_end(vl);
 
    printf("\n");
 
    ReleaseMutex(_log);
}
 
 
//-------------------------------------------------------------------------------------------------
// чтение
//-------------------------------------------------------------------------------------------------
class CReader
{
protected:
    CLockRW m_rwl;
    HANDLE m_hThread;
    DWORD m_dwThreadID;
 
public:
    CReader()
    {
        m_hThread = CreateThread(0, 0, Thread, this, 0, &m_dwThreadID);
    }
 
    ~CReader()
    {
        //WaitForSingleObject(m_hThread, INFINITE);
        //CloseHandle(m_hThread);
    }
 
    static DWORD WINAPI Thread(LPVOID ptr)
    {
        return ((CReader*)ptr)->Thread();
    }
 
    DWORD Thread()
    {
        for (;;)
        {
            m_rwl.Lock(false);
 
            log("R: %s", g_chSharedBuffer);
 
            Sleep((1 + rand() % 5) * 1000);
 
            log("R: try lock");
 
            m_rwl.Unlock(false);
        }
 
        return 0;
    }
};
 
//-------------------------------------------------------------------------------------------------
// запись
//-------------------------------------------------------------------------------------------------
class CWriter
{
protected:
    CLockRW m_rwl;
    HANDLE m_hThread;
    DWORD m_dwThreadID;
    const char* m_pWriteData;
 
public:
    CWriter(const char* pWriteData) : m_pWriteData(pWriteData)
    {
        m_hThread = CreateThread(0, 0, Thread, this, 0, &m_dwThreadID);
    }
 
    ~CWriter()
    {
        //WaitForSingleObject(m_hThread, INFINITE);
        //CloseHandle(m_hThread);
    }
 
    static DWORD WINAPI Thread(LPVOID ptr)
    {
        return ((CWriter*)ptr)->Thread();
    }
 
    DWORD Thread()
    {
        for (;;)
        {
 
            m_rwl.Lock(true);
 
            strcpy(g_chSharedBuffer, m_pWriteData);
 
            log("W: %s", g_chSharedBuffer);
 
            Sleep((1 + rand() % 5) * 1000);
 
            log("W: try lock");
 
            m_rwl.Unlock(true);
        }
 
        return 0;
    }
};
 
int main()
{
    CReader client1;
    CWriter client2("222222222");
    CReader client3;
    CReader client4;
    CWriter client5("555");
    CReader client6;
 
    getchar();
    return 0;
}