Использование несколькими потоками одной функции

DWORD WINAPI ThreadFunc(void *pV)
{   
    Data* pD = (Data*)pV;
    int n, iSleeping(0), MaxCountInConteiner(0);
    n = iGlobal++;
    cout<<"\ntut j:"<<n<<endl<<endl;
 
    for(;;)
    {
        WaitForSingleObject(CreEvent, INFINITE);
        if(pD->Flag == true){
            pD->CountElement = MaxCountInConteiner;
            cout<<"=)threadFUNC="<<n<<endl;
            SetEvent(hArEvent[n]);
            return 0;
        }
        
        if(pD->iDeq.size() < pD->LimitsToEnter){
            ++MaxCountInConteiner;
            pD->iDeq.push_back(n*100);
            
            if(pD->iDeq.front() != n*100)//если добавил не этот поток
            {
                cout<<"aaaaaaaaaa"<<endl;
                --MaxCountInConteiner;
                pD->iDeq.pop_front();
            }
        }
        else
        {
            cout<<"bbbbbbbbbbbb"<<endl;
            pD->iDeq.push_back(n*100);
            pD->iDeq.pop_front();
        }
        cout<<"n="<<n<<endl;
        SetEvent(CreEvent);
        iSleeping = rand()%300;
        Sleep(iSleeping/*/pD->CountThread*/);//если не спать то завершается до вывода статистики
    }

CRITICAL_SECTION main_g_cs;
static HANDLE MainThread, CreThread ,hArThread[MAX_THREAD];
static HANDLE MainEvent,    CreEvent ,hArEvent[MAX_THREAD];
static int iGlobal(0) ;
 
DWORD WINAPI CreateThreadFunc(void *pV);
DWORD WINAPI ThreadFunc(void *pV);
 
struct Data
{
    bool Flag;
    deque<int> iDeq;
    unsigned int LimitsToEnter;
    unsigned int CountThread;
    /*static */unsigned int CountElement;
    int iAr[MAX_THREAD];
    
    Data():Flag(false), CountElement(0){}
};
 
class Rabotnik
{
    //зделать чтоб нельзя было создать боьше 1 обьекта
    Data* pData;
    static Rabotnik* Self;
 
    Rabotnik()
    {
        pData = new Data();
    }
    ~Rabotnik()
    {
        delete pData;
    }
    Rabotnik& operator=(const Rabotnik);
    Rabotnik(const Rabotnik& Root);
public:
    static Rabotnik* CreateFunction()
    {
        if(!Self)
            Self = new Rabotnik();
 
        return Self;
    }
    static void DeleteFunction()
    {
        if(Self)
            delete Self;
    }
    int MainThreadFunc()
    {
            //InitializeCriticalSection(&main_g_cs);
        MainEvent = CreateEvent(0, TRUE, FALSE, L"CreateEventForMainThread1");
        DWORD dw = 0;
        MainThread = CreateThread(0, 0, CreateThreadFunc, pData, /*CREATE_SUSPENDED*/0, &dw);
        WaitForSingleObject(MainEvent, INFINITE);
            //EnterCriticalSection(&main_g_cs);
 
        cout<<"=)MAINTHREADfunc"<<endl;
        
            //DeleteCriticalSection(&main_g_cs);
 
        return 0;
    }
};
 
Rabotnik* Rabotnik::Self = 0;
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    {
    Rabotnik *pRab(Rabotnik::CreateFunction());
    pRab->MainThreadFunc();
    Rabotnik::DeleteFunction();
    }
    if(_CrtDumpMemoryLeaks())
        cout<<"MemoryLeaks!!!"<<endl;
 
    cout<<"=((main"<<endl;
 
    return 0;
}
 
 
DWORD WINAPI CreateThreadFunc(void *pV)
{   
    Data* pD = (Data*)pV;
 
    int CountThreadCreate, LimitsToenter;
    CreEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 
    do{
        cout<<"Enter count of thread (amount must be greater than 0): "<<endl;
        cin>>CountThreadCreate;
    }
    while(1 > CountThreadCreate || CountThreadCreate > 64);
    pD->CountThread = CountThreadCreate;
 
    do{
        cout<<"Enter Limits of entering (amount must be greater than 0): "<<endl;
        cin>>LimitsToenter;
        
    }while(LimitsToenter < 1);
    pD->LimitsToEnter = LimitsToenter;
 
    //DWORD dw2 = 0;
    for(int i = 0; i < pD->CountThread; i++)
    {
        hArEvent[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
        pD->iAr[i] = i; 
        hArThread[i] = CreateThread(0, 0, ThreadFunc, pD, /*CREATE_SUSPENDED*/0, /*&dw2*/0);
    }
 
    char CoEx('c'); 
    cout<<"For stop press any key..."<<endl;
    SetEvent(CreEvent);
    CoEx = _getch();
 
    if(CoEx != 'c')
        pD->Flag = true;
 
    WaitForMultipleObjects(pD->CountThread, hArEvent, TRUE, INFINITE);
    
    deque<int>::iterator iTerDeq;   
    if(pD->iDeq.size() > 0)
    {
        cout<<"Max element in conteiner == "<<pD->CountElement<<"==!!"<<endl<<endl;
        for(iTerDeq = pD->iDeq.begin(); iTerDeq  != pD->iDeq.end(); iTerDeq++)
            cout<<"*iTerDeq = "<<*iTerDeq<<endl;
    }
    else
        cout<<"Conteiner is empty =("<<endl;    
    
    SetEvent(MainEvent);
    //LeaveCriticalSection(&main_g_cs);
    cout<<"=))))))CreateThread"<<endl;
    return 0;
}
 
DWORD WINAPI ThreadFunc(void *pV)
{   
    Data* pD = (Data*)pV;
    int n, iSleeping(0), MaxCountInConteiner(0);
    n = iGlobal++;
    cout<<"\ntut j:"<<n<<endl<<endl;
 
    for(;;)
    {
        WaitForSingleObject(CreEvent, INFINITE);
        if(pD->Flag == true){
            pD->CountElement = MaxCountInConteiner;
            cout<<"=)threadFUNC="<<n<<endl;
            SetEvent(hArEvent[n]);
            return 0;
        }
        
        if(pD->iDeq.size() < pD->LimitsToEnter){
            ++MaxCountInConteiner;
            pD->iDeq.push_back(n*100);
            
            if(pD->iDeq.front() != n*100)//если добавил не этот поток
            {
                cout<<"aaaaaaaaaa"<<endl;
                --MaxCountInConteiner;
                pD->iDeq.pop_front();
            }
        }
        else
        {
            cout<<"bbbbbbbbbbbb"<<endl;
            pD->iDeq.push_back(n*100);
            pD->iDeq.pop_front();
        }
        cout<<"n="<<n<<endl;
        SetEvent(CreEvent);
        iSleeping = rand()%300;
        Sleep(iSleeping/*/pD->CountThread*/);//если не спать то завершается до вывода статистики
    }
    return 0;
}

int main()
{
    control Control; // Некий класс для управления потоками.
 
    HANDLE *pThreadHandles = new HANDLE[NumThreads];
 
    // Создаем столько-то потоков и синхронно стартуем их.
 
    for (int i = 0; i < NumThreads; ++i)
    {
        pThreadHandles[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, &Control, 0, NULL);
    }
 
    Control.start();
 
    // Ждем команды пользователя и даем потокам команду "завершить".
    _getch();
    Control.stop();
 
    // Ожидание завершения.
 
    WaitForMultipleObjects(NumThreads, pThreadHandles, TRUE, INFINITE); 
 
    for (int i = 0; i < NumThreads; ++i)
    {
        CloseHandle(pThreadHandles[i]);
    }
 
    delete [] pThreadHandles;
 
    // Здесь обработка результатов.
    // ...
 
    return 0;
}

unsigned int _stdcall ThreadProc(void *pParam)
{
    control *pCtrl = (control *)pParam;
    DWORD const ThreadId = GetCurrentThreadId(); // Получаем ID текущего потока.
 
    pCtrl->wait_for_start(); // Ждем сигнала "старт".
 
    for (;;)
    {
        if (false != pCtrl->check_for_quit()) // Проверка на завершение.
        {
            break;
        }
 
        Sleep(rand() % 300); // Рандомная задержка.
        
        // Синхронизация доступа к deque (например, на основе CRITICAL_SECTION или spin-lock).
 
        scoped_lock_t ScopedLock(pCtrl->SyncObject);
 
        // Помещаем новый элемент в контейнер.
        item NewItem = {ThreadId};
        pCtrl->Deque.push_back(NewItem);
        
        // Проверка на переполнение.
 
        if (pCtrl->Deque.size() > MaxItems)
        {
            pCtrl->Deque.pop_front();
        }
        
        // Проверка на то, что элемент в голове был вставлен другим потоком.
 
        else if (false == pCtrl->Deque.empty())
        {
            if (ThreadId != pCtrl->Deque.front().ThreadId)
            {
                pCtrl->Deque.pop_front();
            }
        }        
    }
 
    return 0;
}