lll

#include <boost/bind.hpp>
#include <iostream>
#include <string>
#include <windows.h>
using namespace std;

template <class T>
AsynchQueue<T>::AsynchQueue() {
 hMutex = CreateMutex(NULL, FALSE, NULL);
 hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
}

template <class T>
AsynchQueue<T>::~AsynchQueue() {
 CloseHandle(hMutex);
 CloseHandle(hEvent);
}

template <class T>
void AsynchQueue<T>::Enqueue(T* data) {
 WaitForSingleObject(hMutex, INFINITE);
 queue.push_back(data);
 ReleaseMutex(hMutex);
 SetEvent(hEvent);
}

template <class T>
T *AsynchQueue<T>::Dequeue() {
 WaitForSingleObject(hEvent, INFINITE);
 WaitForSingleObject(hMutex, INFINITE);
 T* data = queue.front();
 queue.pop_front();
 if (queue.size() > 0) SetEvent(hEvent);
 ReleaseMutex(hMutex);
 return data;
}

DWORD WINAPI ThreadProcess(LPVOID lpParam);
TaskPool::TaskPool(void)
{
 for (int i=0; i<10; i++) {
  DWORD dwThreadId;
  HANDLE m_thread;
  m_thread = CreateThread(
        NULL,       // default security attributes
        0,          // default stack size
        (LPTHREAD_START_ROUTINE) ThreadProcess,
        this,       // no thread function arguments
        0,          // default creation flags
        &dwThreadId);   // receive thread identifier
  threads.push_back(m_thread);
 }
}

TaskPool::~TaskPool(void)
{
}

void TaskPool::post(TaskMain *tsk) {
 queue.Enqueue(tsk);
}
void TaskPool::start()
{
    TaskMain *tsk = queue.Dequeue();
 tsk->fun_prt();
}

DWORD WINAPI ThreadProcess(LPVOID lpParam)
{
 TaskPool *pool = static_cast<TaskPool *>(lpParam);
 while(1)
 {
  pool->start();
 }
 return 0;
}

 

#pragma once
#include "TaskPool.h"
//#include <boost/function.hpp>
//#include <boost/bind.hpp>
#include <iostream>
#include <string>
#include <list>
#include <windows.h>
#include "TaskMain.h"
using namespace std;

/* Asynchronized Queue */
template <class T>
class AsynchQueue {
public:
 AsynchQueue();
 ~AsynchQueue();

 void Enqueue(T* data);
 T* Dequeue();

private:
 list<T*> queue;
 HANDLE hMutex;
 HANDLE hEvent;

 /*AsynchQueue(const AsynchQueue<T>& q);
 AsynchQueue &operator=(const AsynchQueue<T>&);*/
};

class TaskPool
{
public:
 TaskPool(void);
 ~TaskPool(void);
 void post(TaskMain *tsk);
 void start();
 //BOOL IsStopping();

private:
 /*TaskPool(const TaskPool &);
 TaskPool &operator=(const TaskPool &);*/

 int m_iThread;
 AsynchQueue<TaskMain> queue;
 list<HANDLE> threads;
 HANDLE hMutex;
 BOOL stopMe;
 BOOL m_releaseJob;
};

 

#include "StdAfx.h"
#include "TaskMain.h"

TaskMain::TaskMain(string pstr)
{
}

TaskMain::~TaskMain(void)
{
}

void TaskMain::fun_prt()
{
 printf("%s\n",pstr);
}

 

#pragma once
#include <string>
using namespace std;

class TaskMain
{
public:
 string pstr;
 void fun_prt();
public:
 TaskMain(string pstr);
 ~TaskMain(void);
};

 

/*TaskMain *TM = new TaskMain("do again..");
 TaskPool tp;
 tp.post(TM);*/