C++ Windows-Thread-Pool (Nicht-Boost/C++ 11)

Question

Gibt es eine Möglichkeit, einen Threadpool nur mit C++ - oder Windows C++ - Funktionen zu erstellen? Ich habe keinen Zugriff auf Boost oder irgendwelche Bibliotheken (Ich kann auf Code-Projekt zugreifen, konnte aber nichts Nicht-Unix finden) und ich finde es schwierig, einen Weg zu finden, einen Threadpool zu implementieren.

Ich benutze VS2010, die die C++ 11 Threading noch nicht unterstützt, daher bin ich ein wenig fest!

Answer 1

Es gibt eine API zum Verwalten von Thread-Pools, hier ist ein Link: http://msdn.microsoft.com/en-us/library/windows/desktop/ms686766(v=vs.85).aspx. Möglicherweise möchten Sie jedoch eine Bibliothek finden, die es umschließt, da es kompliziert ist.

Answer 2

Wenn Ihr Ziel ist Windows Vista oder höher können Sie diesen Thread-Pool verwenden: http://msdn.microsoft.com/en-us/library/windows/desktop/ms686980%28v=vs.85%29.aspx

Die Seite hat auch ein Beispiel in C++.

Answer 3

Improve Scalability With New Thread Pool APIs

Answer 4

Es ist ziemlich einfach. Sie benötigen einige Klassen:

Task-Klasse mit einer "run" -Methode - etwas für den Pool-Benutzer zu überschreiben, um ihre eigenen Aufgaben aufzubauen.

Ein Producer-Consumer-ObjektQueue für die Threads, die auf Arbeit warten. Wenn Sie std :: deque haben, ist das ziemlich einfach. Wenn nicht, müssen Sie Ihren eigenen Warteschlangentyp codieren. Neben der Queue-Klasse benötigen Sie noch weitere Synchro-Sachen, vielleicht einen CriticalSection/Mutex zum Schutz der Queue und einen Semaphor für die Threads, auf die gewartet werden soll.

Eine threadPool-Klasse - etwas, das die P-C-Queue enthält, submit (TaskClass aTask) -Methode und andere Sachen.

Ein Stapel von Threads, die im threadPool ctor erstellt wurden - verwenden Sie CreateThread und übergeben Sie die threadPool-Instanz als lpParam-Parameter, damit die Threads sie wieder zurückwerfen können, um Zugriff auf den threadPool zu erhalten.

Die Fäden warten auf die threadPool-> objectQueue für die Arbeit, zB:

// header

class threadPool; 

class task { 
friend class threadPool; 
private: 
     threadPool *myPool; 
public: 
     virtual void run()=0; 
}; 


class PCSqueue{ 
private: 
    CRITICAL_SECTION access; 
    deque<task*> *objectQueue; 
    HANDLE queueSema; 
public: 
    PCSqueue(); 
    void push(task *ref); 
    bool pop(task **ref,DWORD timeout); 
}; 

class threadPool { 
private: 
    int threadCount; 
public: 
    PCSqueue *queue; 
    threadPool(int initThreads); 
    static DWORD _stdcall staticThreadRun(void *param){ 
     threadPool *myPool=(threadPool *)param; 
     task *thisTask; 
     while (myPool->queue->pop(&thisTask,INFINITE)){ 
      thisTask->run(); 
     } 
    } 
    void submit(task *aTask); 
}; 

// cpp

PCSqueue::PCSqueue(){ 
    objectQueue=new deque<task*>; 
    InitializeCriticalSection(&access); 
    queueSema=CreateSemaphore(NULL,0,MAXINT,NULL); 
}; 

void PCSqueue::push(task *ref){ 
    EnterCriticalSection(&access); 
    objectQueue->push_front(ref); 
    LeaveCriticalSection(&access); 
    ReleaseSemaphore(queueSema,1,NULL); 
}; 

bool PCSqueue::pop(task **ref,DWORD timeout){ 
    if (WAIT_OBJECT_0==WaitForSingleObject(queueSema,timeout)) { 
     EnterCriticalSection(&access); 
     *ref=objectQueue->back(); 
     objectQueue->pop_back(); 
     LeaveCriticalSection(&access); 
     return(true); 
    } 
    else 
     return(false); 
}; 

threadPool::threadPool(int initThreads){ 
    queue=new PCSqueue(); 
    for(threadCount=0;threadCount!=initThreads;threadCount++){ 
     CreateThread(NULL,0,staticThreadRun,this,0,0); 
    }; 
}; 

void threadPool::submit(task *aTask){ 
    aTask->myPool=this; 
    queue->push(aTask); 
};