void Server::OnRead ()
{
    if (command == "get")
    {
       Data* data = new Data;
       data->id = ...
       data->data = ...

       AfxBeginThread (Thread, (LPVOID) data, ...)
    }
}

А>Да судя по всему новая функция, для нее качаю последний SDK Что значит складывать запросы в очередь? Разве система сама не распределит какой поток из системного пула будет выполнять тот или иной запрос?

class Server
{
//...
  void OnRead()
  {
    //создаем запрос
    boost::share_ptr<QueryData> pQueryData(new QueryData(...));

    //блокировка очереди
    AutoCriticalSection lockQueue(cs);
    
    //сохраняем запрос в очереди
    querys.push_back(pQueryData);
  }

  void Loop()
  {
    while(!doExit)
    { 
       //блокировка очереди 
       AutoCriticalSection lockQueue(cs);

       //есть задания в очереди?
       if(!querys.empty())
       {
          //извлекаем запрос
          boost::share_ptr<QueryData> pQueryData = querys.front();
          querys.pop();
         
          //убираем блокировку
          lockQueue.release();

          //тут используешь QueueUserWorkItem
          //...

       }       
       ::Sleep(timeToSleep);
    }
  }

//...
private:
  //очередь запросов
  std::queue<boost::share_ptr<QueryData> > querys;
  //для блокировки очереди запросов
  CriticalSection cs;
};

By default, the thread pool has a maximum of 500 threads. To raise this limit, use the WT_SET_MAX_THREADPOOL_THREAD macro defined in Winnt.h.

#define WT_SET_MAX_THREADPOOL_THREADS(Flags,Limit) ((Flags)|=(Limit)<<16)

Use this macro when specifying the Flags parameter. The macro parameters are the desired flags and the new limit (up to (2<<16)-1 threads). However, note that your application can improve its performance by keeping the number of worker threads low.

А>void Server::OnRead ()
А>{
А>    if (command == "get")
А>    {
А>       Data* data = new Data;
       data->>id = ...
       data->>data = ...

А>       AfxBeginThread (Thread, (LPVOID) data, ...)
А>    }
А>}
А>

// ThreadController.h: interface for the ThreadController class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_THREADCONTROLLER_H__BBC6C7A9_6CB8_48C6_861E_ABE432605310__INCLUDED_)
#define AFX_THREADCONTROLLER_H__BBC6C7A9_6CB8_48C6_861E_ABE432605310__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <map>
#include <vector>

#define THREADS_COUNT 5
#define MAX_REQUEST 5
#define MAX_START_THREAD_WAIT 1000
#define MAX_STOP_THREAD_WAIT 10000

struct ThreadEvents
{
    HANDLE hStartEvent;
    HANDLE hStopEvent;
};

enum TC_ExceptionType
{
    UNKNOWN_EXCEPTION,
    MEMORY_EXCEPTION,
    SYSTEM_EXCEPTION
};

struct TC_Exception
{
    TC_ExceptionType eType;
    TC_Exception(TC_ExceptionType tc_eType)
    {
        eType = tc_eType;
    }
};

class ThreadController  
{
public:
    bool SendRequest(DWORD dwParam);
    void CallAPCFunction(DWORD dwParam);
    void SetAPCFunction(PAPCFUNC pfnUserAPC);
    void Unlock();
    void Lock();
    void Decrement(DWORD dwThreadId);
    void Increment(DWORD dwThreadId);
    ThreadController();
    virtual ~ThreadController();
    static ThreadController* pController;
private:
    PAPCFUNC pfnAPC;
    std::map<int, int> m_mapCounters;
    std::map<int, HANDLE> m_mapThreads;
    int iThreadsCount;
    int iMaxRequests;
    LPCRITICAL_SECTION cs;
    HANDLE hStopThreadsEvent;
};

#endif // !defined(AFX_THREADCONTROLLER_H__BBC6C7A9_6CB8_48C6_861E_ABE432605310__INCLUDED_)

// ThreadController.cpp: implementation of the ThreadController class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ThreadController.h"

DWORD WINAPI ThreadFunc(LPVOID);
void WINAPI APCFunc(DWORD);

ThreadController* ThreadController::pController = NULL;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

ThreadController::ThreadController()
{
    ThreadController::pController = this;

    HANDLE hStartEvent = NULL;
    HANDLE hStopEvent = NULL;

    HANDLE hThread = NULL;
    DWORD dwThreadId = 0;

    this->iMaxRequests = MAX_REQUEST;
    this->iThreadsCount = THREADS_COUNT;
    this->hStopThreadsEvent = NULL;
    this->pfnAPC = NULL;

    this->cs = new CRITICAL_SECTION;
    InitializeCriticalSection(this->cs);

    if(this->cs == NULL)
    {
        throw TC_Exception(MEMORY_EXCEPTION);
    }

    hStartEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if(hStartEvent == NULL)
    {
        throw TC_Exception(SYSTEM_EXCEPTION);
    }

    hStopEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if(hStopEvent == NULL)
    {
        throw TC_Exception(SYSTEM_EXCEPTION);
    }

    ThreadEvents *te = new ThreadEvents;
    if(te == NULL)
    {
        throw TC_Exception(MEMORY_EXCEPTION);
    }
    te->hStartEvent = hStartEvent;
    te->hStopEvent = hStopEvent;

    for(int i = 0; i < this->iThreadsCount; i++)
    {
        hThread = CreateThread(NULL, 0, ThreadFunc, te, 0, &dwThreadId);
        if(hThread == NULL)
        {
            throw TC_Exception(SYSTEM_EXCEPTION);
        }
        this->m_mapThreads[dwThreadId] = hThread;
        this->m_mapCounters[dwThreadId] = 0;
        DWORD dwResult = WaitForSingleObject(hStartEvent, MAX_START_THREAD_WAIT);
        if(dwResult == WAIT_TIMEOUT)
        {
            throw TC_Exception(SYSTEM_EXCEPTION);
        }
    }

    delete te;

    if(hStartEvent != NULL)
    {
        CloseHandle(hStartEvent);
    }

    if(hStopEvent != NULL)
    {
        this->hStopThreadsEvent = hStopEvent;
    }
}

ThreadController::~ThreadController()
{
    int Count = this->iThreadsCount;

    HANDLE* Array = new HANDLE[this->iThreadsCount];
    HANDLE* TempArray;

    std::map<int, HANDLE>::const_iterator map_cIter;

    int i = 0;

    for(map_cIter = this->m_mapThreads.begin(); map_cIter != this->m_mapThreads.end(); map_cIter++, i++)
    {
        Array[i] = map_cIter->second;
    }

    for(i = 0; i < this->iThreadsCount; i++)
    {
        SetEvent(this->hStopThreadsEvent);
        DWORD dwResult = WaitForMultipleObjects(Count, Array, false, MAX_STOP_THREAD_WAIT);
        if(dwResult == WAIT_TIMEOUT)
        {
            throw TC_Exception(SYSTEM_EXCEPTION);
        }
        if(i != (this->iThreadsCount - 1))
        {
            TempArray = Array;
            Array = new HANDLE[Count-1];
            for(int j = 0, r = 0 ; j < Count; j++)
            {
                DWORD dwCode = 0;
                if(GetExitCodeThread(TempArray[j], &dwCode))
                {
                    if(dwCode == STILL_ACTIVE)
                    {
                        Array[r] = TempArray[j];
                        r++;
                    }
                }
            }
            delete[] TempArray;
            Count -= 1;
        }
        else
        {
            delete[] Array;
        }
    }

    for(map_cIter = this->m_mapThreads.begin(); map_cIter != this->m_mapThreads.end(); map_cIter++)
    {
        CloseHandle(map_cIter->second);
    }

    CloseHandle(this->hStopThreadsEvent);
    
    DeleteCriticalSection(this->cs);
    delete this->cs;
    
    ThreadController::pController = NULL;
}

void ThreadController::Increment(DWORD dwThreadId)
{
    //std::map<int, int>::iterator map_Iter;
    //map_Iter = m_mapCounters.find(dwThreadId);
    //if(map_Iter != m_mapCounters.end())
    //{
        //map_Iter->second++;
        this->m_mapCounters[dwThreadId]++;
    //}
}

void ThreadController::Decrement(DWORD dwThreadId)
{
    //std::map<int, int>::iterator map_Iter;
    //map_Iter = m_mapCounters.find(dwThreadId);
    //if(map_Iter != m_mapCounters.end())
    //{
        //map_Iter->second--;
        this->m_mapCounters[dwThreadId]--;
    //}
}

void ThreadController::Lock()
{
    EnterCriticalSection(this->cs);
}

void ThreadController::Unlock()
{
    LeaveCriticalSection(this->cs);
}

void ThreadController::SetAPCFunction(PAPCFUNC pfnUserAPC)
{
    this->pfnAPC = pfnUserAPC;
}

void ThreadController::CallAPCFunction(DWORD dwParam)
{
    (this->pfnAPC)(dwParam);
}

bool ThreadController::SendRequest(DWORD dwParam)
{
    bool bResult = false;
    DWORD dwThreadId;
    int Min;
    std::map<int, int>::const_iterator map_cIter;
    this->Lock();
    map_cIter = this->m_mapCounters.begin();
    dwThreadId = map_cIter->first;
    Min = map_cIter->second;
    for(;map_cIter != this->m_mapCounters.end(); map_cIter++)
    {
        if(map_cIter->second < Min)
        {
            dwThreadId = map_cIter->first;
            Min = map_cIter->second;
        }
    }
    this->m_mapCounters[dwThreadId]++;
    if((Min + 1) > MAX_REQUEST)
    {
        bResult = false;
    }
    else
    {
        QueueUserAPC(APCFunc, this->m_mapThreads[dwThreadId], dwParam);
        bResult = true;
    }
    this->Unlock();
    return bResult;
}

DWORD WINAPI ThreadFunc(LPVOID lpvThreadParm)
{
    ThreadEvents *te = (ThreadEvents *) lpvThreadParm;
    
    HANDLE hStartEvent = te->hStartEvent;
    HANDLE hStopEvent = te->hStopEvent;
    
    SetEvent(hStartEvent);

    for(;;)
    {
        DWORD dwResult = WaitForSingleObjectEx(hStopEvent, INFINITE, true);
        if(dwResult == WAIT_OBJECT_0)
        {
            break;
        }
        else
        {
            if(dwResult == WAIT_IO_COMPLETION)
            {
                continue;
            }
            else
            {
                break;
            }
        }
    }

    return 0;
}

void WINAPI APCFunc(DWORD dwParam)
{
    if(ThreadController::pController != NULL)
    {
        ThreadController::pController->CallAPCFunction(dwParam);
        ThreadController::pController->Lock();
        ThreadController::pController->Decrement(GetCurrentThreadId());
        ThreadController::pController->Unlock();
    }
}

        ThreadController* tc;
        try
        {
            tc = new ThreadController();
            tc->SetAPCFunction(pfnAPCControlService);
        }
        catch(TC_Exception)
        {
            ThreadController::pController = NULL;
        }

        try
        {
            delete tc;
            ThreadController::pController = NULL;
        }
        catch(TC_Exception)
        {
            ThreadController::pController = NULL;
        }