mitkThreadMasterWorker.h

/*=========================================================================

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

=========================================================================*/

#ifndef __mitkThreadMaster_h
#define __mitkThreadMaster_h

#include "mitkObject.h"

class mitkThreadDelegate;
class MITK_COMMON_API mitkThreadWorker :public mitkObject
{
public:
    MITK_TYPE(mitkThreadWorker,mitkObject)
    mitkThreadWorker(){}
    friend class mitkThreadMaster;
protected:
    virtual ~mitkThreadWorker(){}
    virtual int TasksPerTime() {return 1;}
    virtual void SendTaskBag(void *taskBag) {}
    virtual void DoTask(int taskID,int taskNumber)=0;
    virtual mitkThreadWorker *Duplicate()=0;
private:
    mitkThreadWorker(const mitkThreadWorker&);
    void operator = (const mitkThreadWorker&);
};

class MITK_COMMON_API mitkThreadWorkerCreator : public mitkObject
{
public:
    MITK_TYPE(mitkThreadWorkerCreator,mitkObject)
    mitkThreadWorkerCreator(){}
    virtual int GetWorkerNum();
    virtual mitkThreadWorker* CreateThreadWorker(int WorkerID)=0;
protected:
    virtual ~mitkThreadWorkerCreator(){}
private:
    mitkThreadWorkerCreator(const mitkThreadWorkerCreator&);
    void operator = (const mitkThreadWorkerCreator&);
};

class mitkThread;
class mitkConditionVariable;
#include "mitkMutex.h"
class MITK_COMMON_API mitkThreadMaster : public mitkObject
{
public:
    MITK_TYPE(mitkThreadMaster,mitkObject)
    mitkThreadMaster(mitkThreadWorkerCreator* workerCreator);
    mitkThreadMaster(mitkThreadWorker* sampleWorker);
    mitkThreadMaster(int threadNumber,mitkThreadWorker* sampleWorker);
    int GetThreadNumber() const
    {
        return m_threadNumber;
    }
    void DoTasks(unsigned long taskNumber,unsigned long startID=0,void *taskBag=NULL);

protected:
    virtual ~mitkThreadMaster();

private:
    mitkThreadMaster (const mitkThreadMaster&);
    void operator = (const mitkThreadMaster&);

    int m_threadNumber;
    mitkThreadDelegate** m_threads;
    int *m_threadIDs;

    mitkThreadWorker **m_workers;

    unsigned long m_taskNumber;
    unsigned long m_taskProgress;
    unsigned long m_taskStartID;

    int m_toDoValue,m_doneValue;
    mitkConditionVariable *m_toDoCV;
    mitkConditionVariable *m_doneCV;
    mitkMutex *m_progressMutex;

    void _init(mitkThreadWorker* sampleWorker);
    unsigned long _getProgress(int step)
    {
        unsigned long prog;
        m_progressMutex->Lock();
        prog=m_taskProgress;
        m_taskProgress+=step;
        m_progressMutex->Unlock();
        return prog;
    }
    void _threadEntrance(void *param);

};

#endif

---