TaskThread类库简介

最新推荐文章于 2022-06-19 20:55:30 发布

superyys

最新推荐文章于 2022-06-19 20:55:30 发布

阅读量1.4k

点赞数 1

文章标签： class fun null facet 任务 delete

本文链接：https://blog.csdn.net/superyys/article/details/3389784

版权

    近日灵感飙升，突发奇想,模拟操作系统调度进程的方式写了个调度函数的类库，暂称为TaskThread,此类皆组合或继承自TTaskThread类，它们是一种奇妙的类，它们可以把一个一个的现成函数当成一个“process"强行塞入TaskThread的线程运行，用户不再需要额外初始化线程类。本函数库甚至能模拟操作系统的方式对“任务函数”进行调度运行，目前的策略支持批处理和并行模式，类似OS的批处理文件运行和多任务并发执行。为了便于C++用户者使用，除了对普通函数实现了“任务化”管理之外，本类库所有任务类均实现了对C++类函数作“任务化”管理的TClassTaskThread另一系列版本。
      TTaskThread类库总共包括了大大小小几十个类，提供了跨平台(目前只实现的windows)的线程、互斥等基础类，主要实现功能的类是TClassTaskThread系列类，最多带9个参数的函数或类函数的任务管理，以下是类继承关系。
以下是类继承关系图
-TThreadMutex 互斥类
-TSimpleThread 基础线程类
-TClassTaskThread 运行类函数的任务类基类
-TClassNoRetNoArgTaskThread
-TClassNoRet1ArgTaskThread
-TClassNoRet2ArgTaskThread
...直到支持9个参数的无返回类函数任务类
-TTaskThread 运行普通函数任务类基类
-TNoRetNoArgTaskThread
-TNoRet1ArgTaskThread
-TNoRet2ArgTaskThread
......直到支持9个参数的无返回函数任务类
-TMutiTaskThread9BatchFacet 批处理运行适应类
-TMutiTaskThread9ParallelFacet并行运行适应类
-TClassMutiTaskThread9BatchFacet 批处理运行适应类 (类函数)
-TClassMutiTaskThread9ParallelFacet并行运行适应类 (类函数)
-TMutiTaskThread9 多任务管理器类
-TClassMutiTaskThread9 多任务管理器类 (类函数)
-TMutiTaskThread9<TMutiTaskThread9BatchFacet> TBatchTaskThreads批处理管理器类
-TMutiTaskThread9<TMutiTaskThread9ParallelFacet> TParallelTaskThreads并行管理器类
-TClassMutiTaskThread9<TClassMutiTaskThread9BatchFacet> TClassBatchTaskThreads批处理管理器类 (类函数)
-TClassMutiTaskThread9<TClassMutiTaskThread9ParallelFacet> TClassParallelTaskThreads并行管理器类 (类函数)

    源代码因为大量使用模板、类函数指针等高级的C++特性，因此需要比较新版，接近C99标准的C++编译器，笔者是使用Borland C++ 6编译通过。
以下是一个管理批处理任务的使用示例：
int c=0;
void AsignC()
{
        c=a+b;
}

int negtive(int d)
{
        return -d;
}

TBatchTaskThreads tbth9;

tbth9.PushBackTaskNoRet(AsignC);
tbth9.PushBackTaskRet<int,int>(negtive,112);
tbth9.PushBackTaskRet<int,int>(negtive,9);
tbth9.Start();
tbth9.WaitForMutiTask();
ShowMessage(IntToStr(GetTickCount()-curtime));

ShowMessage(IntToStr(c));
int testi=tbth9.GetRunedRet<int>(1);
ShowMessage(IntToStr(testi));
testi=tbth9.GetRunedRet<int>(2);
ShowMessage(IntToStr(testi));
tbth9.ClearTask();
    可以看出，用户只需要把待批处理运行的函数按次序塞入tbth9，然后运行Start，再WaitForMutiTask，之后就可以按照需要取回函数运行结果。可见，TBatchTaskThreads 调用方式是非常简单的。
    并行方式的调用方式类似，不再赘述。
以下是完整的源代码，有兴趣者可以复制并散播，但请不要去掉文件头的版权信息，请尊重作者的精神享有权。

完整源代码和C++Builder 6的Demo本人已上传到download.csdn.net，可以直接搜索"TTaskThread"下载。
读者还可以email至superyys@163.com索取，绝不吝啬。

完整源代码:

/****************************************************************************
// TTASKTHREAD.H: Task thread cross platform library
// Include Mutex,Simplethread,taskthread utility cross platform class.

// Version 1.0 All rights reserved 2008
   Author: Mars Yi(Yi Yansong), Tencent Inc.
   Date: 2008 8.24
                <superyys@163.com>
****************************************************************************/
//---------------------------------------------------------------------------

#ifndef TTaskThreadH
#define TTaskThreadH

#define MSWINDOWS
//---------------------------------------------------------------------------
#ifdef MSWINDOWS
#include <windows.h>
#endif
#ifdef LINUX
#include <unistd.h>
#endif
#include <exception>
#include <typeinfo>
#include <map>
#include <vector>
#include <string>
#include <iostream>
#include <list>
#include <exception>
using namespace std;
//---------------------------------------------------------------------------

namespace stladd
{
typedef void (*ThreadNotify)(void *);

void MilliSleep(int m)
{
#ifdef MSWINDOWS
Sleep(m);
#endif
#ifdef LINUX
usleep(m*1000);
#endif

}

unsigned long GetBootTickCount()
{
#ifdef MSWINDOWS
return GetTickCount();
#endif
#ifdef LINUX

#endif

}

#ifdef MSWINDOWS
class TThreadMutex
{
public:
        CRITICAL_SECTION CriticalSection;
        TThreadMutex()
        {
                InitializeCriticalSection(&CriticalSection);
        }
        ~TThreadMutex()
        {
                DeleteCriticalSection(&CriticalSection);
        }
};
#endif
#ifdef LINUX
class TThreadMutex
{
};
#endif

bool LockMutex(TThreadMutex* mutex)
{
#ifdef MSWINDOWS
return TryEnterCriticalSection(&mutex->CriticalSection);
#endif
}

bool LockMutexBlocking(TThreadMutex* mutex)
{
#ifdef MSWINDOWS
EnterCriticalSection(&mutex->CriticalSection);
#endif
}

void UnLockMutex(TThreadMutex* mutex)
{
#ifdef MSWINDOWS
        LeaveCriticalSection(&mutex->CriticalSection);
#endif
}
#ifdef MSWINDOWS
DWORD WINAPI ThreadWapper(LPVOID lpThreadParameter);
class TSimpleThread
{
private:
    HANDLE SyncEvent;
protected:
    bool FFinished;
    int WaitFor(int mseconds)
    {
        WaitForSingleObject(SyncEvent,mseconds);
        return ReturnValue;
    }
public:
    HANDLE Handle;
    DWORD ThreadID;
    bool Terminated;
    int ReturnValue;
    //在栈中生成对象时,FreeOnTerminate只能为false,否则可能有不可预料的后果
    bool FreeOnTerminate;
    ThreadNotify OnTerminate;
    void CancelCreateSuspended()
    {
        ResumeThread(Handle);
    }
    void Terminate()
    {
        Terminated=true;
    }
    bool GetFinished()
    {
        return FFinished;
    }
    int WaitFor()
    {
    /*
        while (!FFinished)
                MilliSleep(1);
                */
        WaitForSingleObject(SyncEvent,INFINITE);
        return ReturnValue;

}

    TSimpleThread(bool ACreateSuspended)
    {
        OnTerminate=NULL;
        FFinished=false;
        Terminated=false;
        FreeOnTerminate=false;
        SyncEvent= CreateEvent(NULL, true, false, NULL);
        unsigned long CreationFlags;
        if (ACreateSuspended)
                CreationFlags=CREATE_SUSPENDED;
        else
                CreationFlags=0;
        Handle=CreateThread(NULL,0,ThreadWapper,(void*)this,CreationFlags,&ThreadID);
        if (Handle==0)
                throw logic_error("Error on Creating thread");
    }
    virtual ~TSimpleThread()
    {
        if (!FFinished)
        {
                Terminate();
                WaitFor(1000);
                if (!FFinished)
                {
                    DWORD code;
                    bool ret=TerminateThread(Handle,code);
                    if (ret==0)
                            throw logic_error("Error on terminate thread");
                }
        }
        CloseHandle(SyncEvent);
    }
    virtual void Execute(){};
    friend DWORD WINAPI ThreadWapper(LPVOID lpThreadParameter);
};

DWORD WINAPI ThreadWapper(LPVOID lpThreadParameter)
{
        TSimpleThread* sth=(TSimpleThread*)lpThreadParameter;
        sth->Execute();
        if (sth->OnTerminate)
            sth->OnTerminate(sth);
        SetEvent(sth->SyncEvent);
        if (sth->FreeOnTerminate)
                delete sth;
        sth->FFinished=true;
}
#endif

#ifdef LINUX

#endif
class Dummy
{
};
template <class T>
class TClassTaskThread : public TSimpleThread
{
private:
#ifdef MSWINDOWS
        HANDLE IdelSyncEvent;
        HANDLE TaskSyncEvent;
#endif
        TThreadMutex* mutexwithmain;
protected:
        T m_t;
        void (T::*FTaskFun)();
        virtual void TaskRun(){}
        virtual void Execute()
        {
                while (!Terminated)
                {
                        if (FTaskFun)
                        {
                                #ifdef MSWINDOWS
                                ResetEvent(TaskSyncEvent);
                                #endif
                                TaskRun();
                                #ifdef MSWINDOWS
                                SetEvent(TaskSyncEvent);
                                #endif
                                if (OnTaskFinished)
                                    OnTaskFinished(this);
                                //while (!LockMutex(mutexwithmain)) ;
                                LockMutexBlocking(mutexwithmain);
                                FTaskFun=NULL;
                                UnLockMutex(mutexwithmain);
                                #ifdef MSWINDOWS
                                ResetEvent(IdelSyncEvent);
                                #endif
                        }
                        #ifdef MSWINDOWS
                        WaitForSingleObject(IdelSyncEvent,INFINITE);
                        #endif
                        #ifdef LINUX
                        MilliSleep(1);
                        #endif
                }
        }
        bool RunTask(void (T::*fun)(),T t)
        {
                if (fun==NULL)
                        return false;
                if (!IsIdle())
                        return false;
                m_t=t;
                //while (!LockMutex(mutexwithmain)) ;
                LockMutexBlocking(mutexwithmain);
                FTaskFun=fun;
                UnLockMutex(mutexwithmain);
                #ifdef MSWINDOWS
                SetEvent(IdelSyncEvent);
                #endif

                return true;
        }
        bool InternalWaitForTaskNoWait()
        {
                #ifdef MSWINDOWS
                return WaitForSingleObject(TaskSyncEvent,0)!=WAIT_TIMEOUT;
                #endif
                #ifdef LINUX
                while (!IsIdle()) MilliSleep(1);
                #endif
        }
        void InternalWaitForTask()
        {
                #ifdef MSWINDOWS
                WaitForSingleObject(TaskSyncEvent,INFINITE);
                #endif
                #ifdef LINUX
                while (!IsIdle()) MilliSleep(1);
                #endif
        }
public:
        ThreadNotify OnTaskFinished;
        TClassTaskThread(bool ACreateSuspended)
        : TSimpleThread(ACreateSuspended)
        {
                #ifdef MSWINDOWS
                IdelSyncEvent= CreateEvent(NULL, true, false, NULL);
                TaskSyncEvent= CreateEvent(NULL, true, false, NULL);
                #endif
                OnTaskFinished=NULL;
                mutexwithmain=new TThreadMutex();
                //while (!LockMutex(mutexwithmain)) ;
                LockMutexBlocking(mutexwithmain);
                FTaskFun=NULL;
                UnLockMutex(mutexwithmain);
                #ifdef MSWINDOWS
                ResetEvent(IdelSyncEvent);
                #endif
        }
        virtual ~TClassTaskThread(void)
        {
                delete mutexwithmain;
                #ifdef MSWINDOWS
                Terminate();
                SetEvent(IdelSyncEvent);
                TSimpleThread::WaitFor(1000);
                CloseHandle(TaskSyncEvent);
                CloseHandle(IdelSyncEvent);
                #endif
        }
        bool IsIdle()
        {
                bool ret;
                //while (!LockMutex(mutexwithmain)) ;
                LockMutexBlocking(mutexwithmain);
                ret=FTaskFun==NULL;
                UnLockMutex(mutexwithmain);
                return ret;
        }
        friend class TClassMutiTaskThread9BatchFacet;
        friend class TClassMutiTaskThread9ParallelFacet;
};
class TTaskThread : public TSimpleThread
{
private:
#ifdef MSWINDOWS
        HANDLE IdelSyncEvent;
        HANDLE TaskSyncEvent;
#endif
        TThreadMutex* mutexwithmain;
protected:
        void *FTaskFun;
        virtual void TaskRun(){}
        virtual void Execute()
        {
                while (!Terminated)
                {
                        if (FTaskFun)
                        {
                                #ifdef MSWINDOWS
                                ResetEvent(TaskSyncEvent);
                                #endif
                                TaskRun();
                                #ifdef MSWINDOWS
                                SetEvent(TaskSyncEvent);
                                #endif
                                if (OnTaskFinished)
                                    OnTaskFinished(this);
                                //while (!LockMutex(mutexwithmain)) ;
                                LockMutexBlocking(mutexwithmain);
                                FTaskFun=NULL;
                                UnLockMutex(mutexwithmain);
                                #ifdef MSWINDOWS
                                ResetEvent(IdelSyncEvent);
                                #endif
                        }
                        #ifdef MSWINDOWS
                        WaitForSingleObject(IdelSyncEvent,INFINITE);
                        #endif
                        #ifdef LINUX
                        MilliSleep(1);
                        #endif
                }
        }
        bool RunTask(void *fun)
        {
                if (fun==NULL)
                        return false;
                if (!IsIdle())
                        return false;
                //while (!LockMutex(mutexwithmain)) ;
                LockMutexBlocking(mutexwithmain);
                FTaskFun=fun;
                UnLockMutex(mutexwithmain);
                #ifdef MSWINDOWS
                SetEvent(IdelSyncEvent);
                #endif

};
class TNoRetNoArgTaskThread : public TTaskThread
{
public:
        TNoRetNoArgTaskThread(bool ACreateSuspended):TTaskThread(ACreateSuspended)
        {
        }
        bool RunTask(void *fun)
        {
                return TTaskThread::RunTask(fun);
        }
        void WaitForTask()
        {
                TTaskThread::InternalWaitForTask();
        }
protected:
        virtual void TaskRun()
        {
                typedef void (*NoRetNoArg)();
                NoRetNoArg tmp=(NoRetNoArg)FTaskFun;
                tmp();
        }

};

template<class T,class ARG1>
class TClassNoRet1ArgTaskThread : public TClassNoRetNoArgTaskThread<T>
{
private:
        ARG1 m_arg1;
public:
        TClassNoRet1ArgTaskThread(bool ACreateSuspended):TClassNoRetNoArgTaskThread<T>(ACreateSuspended)
        {
        }
        bool RunTask(void (T::*fun)(ARG1),ARG1 arg1,T t)
        {
                SetArg(arg1);
                return TClassTaskThread<T>::RunTask((void (T::*)())fun,t);
        }
//        friend class TBatchTaskThread9;
protected:
//        template<class ARG1>
        void SetArg(ARG1 arg1)
        {
                m_arg1=arg1;
        }
        virtual void TaskRun()
        {
                typedef void (T::*NoRetNo1Arg)(ARG1);
                NoRetNo1Arg tmp=(NoRetNo1Arg)FTaskFun;
                (m_t.*tmp)(m_arg1);
        }

};

template<class ARG1>
class TNoRet1ArgTaskThread : public TNoRetNoArgTaskThread
{
private:
        ARG1 m_arg1;
public:
        TNoRet1ArgTaskThread(bool ACreateSuspended):TNoRetNoArgTaskThread(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1)
        {
                SetArg(arg1);
                return TTaskThread::RunTask(fun);
        }
//        friend class TBatchTaskThread9;
protected:
//        template<class ARG1>
        void SetArg(ARG1 arg1)
        {
                m_arg1=arg1;
        }
        virtual void TaskRun()
        {
                typedef void (*NoRetNo1Arg)(ARG1);
                NoRetNo1Arg tmp=(NoRetNo1Arg)FTaskFun;
                tmp(m_arg1);
        }

};

template<class T,class ARG1,class ARG2>
class TClassNoRet2ArgTaskThread : public TClassNoRet1ArgTaskThread<T,ARG1>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
public:
        TClassNoRet2ArgTaskThread(bool ACreateSuspended):TClassNoRet1ArgTaskThread<T,ARG1>(ACreateSuspended)
        {
        }
        bool RunTask(void (T::*fun)(ARG1,ARG2),ARG1 arg1,ARG2 arg2,T t)
        {
                SetArg(arg1,arg2);
                return TClassTaskThread<T>::RunTask((void (T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2)
        {
                m_arg1=arg1;
                m_arg2=arg2;
        }
        virtual void TaskRun()
        {
                typedef void (T::*NoRetNo2Arg)(ARG1,ARG2);
                NoRetNo2Arg tmp=(NoRetNo2Arg)FTaskFun;
                (m_t.*tmp)(m_arg1,m_arg2);
        }

};

template<class ARG1,class ARG2>
class TNoRet2ArgTaskThread : public TNoRet1ArgTaskThread<ARG1>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
public:
        TNoRet2ArgTaskThread(bool ACreateSuspended):TNoRet1ArgTaskThread<ARG1>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2)
        {
                SetArg(arg1,arg2);
                return TTaskThread::RunTask(fun);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2)
        {
                m_arg1=arg1;
                m_arg2=arg2;
        }
        virtual void TaskRun()
        {
                typedef void (*NoRetNo2Arg)(ARG1,ARG2);
                NoRetNo2Arg tmp=(NoRetNo2Arg)TNoRet1ArgTaskThread<ARG1>::FTaskFun;
                tmp(m_arg1,m_arg2);
        }

};

template<class T,class ARG1,class ARG2,class ARG3>
class TClassNoRet3ArgTaskThread : public TClassNoRet2ArgTaskThread<T,ARG1,ARG2>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
public:
        TClassNoRet3ArgTaskThread(bool ACreateSuspended):TClassNoRet2ArgTaskThread<T,ARG1,ARG2>(ACreateSuspended)
        {
        }
        bool RunTask(void (T::*fun)(ARG1,ARG2,ARG3),ARG1 arg1,ARG2 arg2,ARG3 arg3,T t)
        {
                SetArg(arg1,arg2,arg3);
                return TClassTaskThread<T>::RunTask((void (T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
        }
        virtual void TaskRun()
        {
                typedef void (T::*NoRetNo3Arg)(ARG1,ARG2,ARG3);
                NoRetNo3Arg tmp=(NoRetNo3Arg)FTaskFun;
                (m_t.*tmp)(m_arg1,m_arg2,m_arg3);
        }

};

template<class ARG1,class ARG2,class ARG3>
class TNoRet3ArgTaskThread : public TNoRet2ArgTaskThread<ARG1,ARG2>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
public:
        TNoRet3ArgTaskThread(bool ACreateSuspended):TNoRet2ArgTaskThread<ARG1,ARG2>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3)
        {
                SetArg(arg1,arg2,arg3);
                return TTaskThread::RunTask(fun);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
        }
        virtual void TaskRun()
        {
                typedef void (*NoRetNo3Arg)(ARG1,ARG2,ARG3);
                NoRetNo3Arg tmp=(NoRetNo3Arg)TNoRet1ArgTaskThread<ARG1>::FTaskFun;
                tmp(m_arg1,m_arg2,m_arg3);
        }

};

template<class T,class ARG1,class ARG2,class ARG3,class ARG4>
class TClassNoRet4ArgTaskThread : public TClassNoRet3ArgTaskThread<T,ARG1,ARG2,ARG3>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
public:
        TClassNoRet4ArgTaskThread(bool ACreateSuspended):TClassNoRet3ArgTaskThread<T,ARG1,ARG2,ARG3>(ACreateSuspended)
        {
        }
        bool RunTask(void (T::*fun)(ARG1,ARG2,ARG3,ARG4),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,T t)
        {
                SetArg(arg1,arg2,arg3,arg4);
                return TClassTaskThread<T>::RunTask((void (T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
        }
        virtual void TaskRun()
        {
                typedef void (T::*NoRetNo4Arg)(ARG1,ARG2,ARG3,ARG4);
                NoRetNo4Arg tmp=(NoRetNo4Arg)FTaskFun;
                (m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4);
        }

};

template<class ARG1,class ARG2,class ARG3,class ARG4>
class TNoRet4ArgTaskThread : public TNoRet3ArgTaskThread<ARG1,ARG2,ARG3>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
public:
        TNoRet4ArgTaskThread(bool ACreateSuspended):TNoRet3ArgTaskThread<ARG1,ARG2,ARG3>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4)
        {
                SetArg(arg1,arg2,arg3,arg4);
                return TTaskThread::RunTask(fun);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
        }
        virtual void TaskRun()
        {
                typedef void (*NoRetNo4Arg)(ARG1,ARG2,ARG3,ARG4);
                NoRetNo4Arg tmp=(NoRetNo4Arg)TNoRet1ArgTaskThread<ARG1>::FTaskFun;
                tmp(m_arg1,m_arg2,m_arg3,m_arg4);
        }

};

template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
class TClassNoRet5ArgTaskThread : public TClassNoRet4ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
public:
        TClassNoRet5ArgTaskThread(bool ACreateSuspended):TClassNoRet4ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4>(ACreateSuspended)
        {
        }
        bool RunTask(void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,T t)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5);
                return TClassTaskThread<T>::RunTask((void (T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
        }
        virtual void TaskRun()
        {
                typedef void (T::*NoRetNo5Arg)(ARG1,ARG2,ARG3,ARG4,ARG5);
                NoRetNo5Arg tmp=(NoRetNo5Arg)FTaskFun;
                (m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5);
        }

};

template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
class TNoRet5ArgTaskThread : public TNoRet4ArgTaskThread<ARG1,ARG2,ARG3,ARG4>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
public:
        TNoRet5ArgTaskThread(bool ACreateSuspended):TNoRet4ArgTaskThread<ARG1,ARG2,ARG3,ARG4>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5);
                return TTaskThread::RunTask(fun);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
        }
        virtual void TaskRun()
        {
                typedef void (*NoRetNo5Arg)(ARG1,ARG2,ARG3,ARG4,ARG5);
                NoRetNo5Arg tmp=(NoRetNo5Arg)TNoRet1ArgTaskThread<ARG1>::FTaskFun;
                tmp(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5);
        }

};

template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
class TClassNoRet6ArgTaskThread : public TClassNoRet5ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
public:
        TClassNoRet6ArgTaskThread(bool ACreateSuspended):TClassNoRet5ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5>(ACreateSuspended)
        {
        }
        bool RunTask(void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,T t)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6);
                return TClassTaskThread<T>::RunTask((void (T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
        }
        virtual void TaskRun()
        {
                typedef void (T::*NoRetNo6Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
                NoRetNo6Arg tmp=(NoRetNo6Arg)FTaskFun;
                (m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6);
        }

};

template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
class TNoRet6ArgTaskThread : public TNoRet5ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
public:
        TNoRet6ArgTaskThread(bool ACreateSuspended):TNoRet5ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6);
                return TTaskThread::RunTask(fun);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
        }
        virtual void TaskRun()
        {
                typedef void (*NoRetNo6Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
                NoRetNo6Arg tmp=(NoRetNo6Arg)TNoRet1ArgTaskThread<ARG1>::FTaskFun;
                tmp(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6);
        }

};

template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
class TClassNoRet7ArgTaskThread : public TClassNoRet6ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
public:
        TClassNoRet7ArgTaskThread(bool ACreateSuspended):TClassNoRet6ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(ACreateSuspended)
        {
        }
        bool RunTask(void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,T t)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
                return TClassTaskThread<T>::RunTask((void (T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
        }
        virtual void TaskRun()
        {
                typedef void (T::*NoRetNo7Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7);
                NoRetNo7Arg tmp=(NoRetNo7Arg)FTaskFun;
                (m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7);
        }

};

template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
class TNoRet7ArgTaskThread : public TNoRet6ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
public:
        TNoRet7ArgTaskThread(bool ACreateSuspended):TNoRet6ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
                return TTaskThread::RunTask(fun);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
        }
        virtual void TaskRun()
        {
                typedef void (*NoRetNo7Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7);
                NoRetNo7Arg tmp=(NoRetNo7Arg)TNoRet1ArgTaskThread<ARG1>::FTaskFun;
                tmp(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7);
        }

};

template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
class TClassNoRet8ArgTaskThread : public TClassNoRet7ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
        ARG8 m_arg8;
public:
        TClassNoRet8ArgTaskThread(bool ACreateSuspended):TClassNoRet7ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(ACreateSuspended)
        {
        }
        bool RunTask(void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,T t)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
                return TClassTaskThread<T>::RunTask((void (T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
                m_arg8=arg8;
        }
        virtual void TaskRun()
        {
                typedef void (T::*NoRetNo8Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8);
                NoRetNo8Arg tmp=(NoRetNo8Arg)FTaskFun;
                (m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8);
        }

};

template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
class TNoRet8ArgTaskThread : public TNoRet7ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
        ARG8 m_arg8;
public:
        TNoRet8ArgTaskThread(bool ACreateSuspended):TNoRet7ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
                return TTaskThread::RunTask(fun);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
                m_arg8=arg8;
        }
        virtual void TaskRun()
        {
                typedef void (*NoRetNo8Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8);
                NoRetNo8Arg tmp=(NoRetNo8Arg)TNoRet1ArgTaskThread<ARG1>::FTaskFun;
                tmp(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8);
        }

};

template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
class TClassNoRet9ArgTaskThread : public TClassNoRet8ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
        ARG8 m_arg8;
        ARG9 m_arg9;
public:
        TClassNoRet9ArgTaskThread(bool ACreateSuspended):TClassNoRet8ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(ACreateSuspended)
        {
        }
        bool RunTask(void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9,T t)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
                return TClassTaskThread<T>::RunTask((void (T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
                m_arg8=arg8;
                m_arg9=arg9;
        }
        virtual void TaskRun()
        {
                typedef void (T::*NoRetNo9Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9);
                NoRetNo9Arg tmp=(NoRetNo9Arg)FTaskFun;
                (m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8,m_arg9);
        }

};

template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
class TNoRet9ArgTaskThread : public TNoRet8ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
        ARG8 m_arg8;
        ARG9 m_arg9;
public:
        TNoRet9ArgTaskThread(bool ACreateSuspended):TNoRet8ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
                return TTaskThread::RunTask(fun);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
                m_arg8=arg8;
                m_arg9=arg9;
        }
        virtual void TaskRun()
        {
                typedef void (*NoRetNo9Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9);
                NoRetNo9Arg tmp=(NoRetNo8Arg)TNoRet1ArgTaskThread<ARG1>::FTaskFun;
                tmp(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8,m_arg9);
        }

};

template<class T,class RET>
class TClassRetNoArgTaskThread : public TClassTaskThread<T>
{
public:
        TClassRetNoArgTaskThread(bool ACreateSuspended):TClassTaskThread<T>(ACreateSuspended)
        {
        }
        RET GetReturnValue()
        {
                return ret;
        }
        bool RunTask(RET (T::*fun)(),T t)
        {
                return TClassTaskThread<T>::RunTask((void(T::*)())fun,t);
        }
        RET WaitForTask()
        {
                TClassTaskThread<T>::InternalWaitForTask();
                return ret;
        }
protected:
        RET ret;
        virtual void TaskRun()
        {
                typedef RET (T::*RetNoArg)();
                RetNoArg tmp=(RetNoArg)FTaskFun;
                ret=(m_t.*tmp)();
        }
};

template<class RET>
class TRetNoArgTaskThread : public TTaskThread
{
public:
        TRetNoArgTaskThread(bool ACreateSuspended):TTaskThread(ACreateSuspended)
        {
        }
        RET GetReturnValue()
        {
                return ret;
        }
        bool RunTask(void *fun)
        {
                return TTaskThread::RunTask(fun);
        }
        RET WaitForTask()
        {
                TTaskThread::InternalWaitForTask();
                return ret;
        }

protected:
        RET ret;
        virtual void TaskRun()
        {
                typedef RET (*RetNoArg)();
                RetNoArg tmp=(RetNoArg)FTaskFun;
                ret=tmp();

        }

};

template<class T,class RET,class ARG1>
class TClassRet1ArgTaskThread : public TClassRetNoArgTaskThread<T,RET>
{
private:
        ARG1 m_arg1;
public:
        TClassRet1ArgTaskThread(bool ACreateSuspended):TClassRetNoArgTaskThread<T,RET>(ACreateSuspended)
        {
        }
        bool RunTask(RET (T::*fun)(ARG1),ARG1 arg1,T t)
        {
                SetArg(arg1);
                return TClassTaskThread<T>::RunTask((void(T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1)
        {
                m_arg1=arg1;
        }
        virtual void TaskRun()
        {
                typedef RET (T::*Ret1Arg)(ARG1);
                Ret1Arg tmp=(Ret1Arg)FTaskFun;
                ret=(m_t.*tmp)(m_arg1);
        }

};

template<class RET,class ARG1>
class TRet1ArgTaskThread : public TRetNoArgTaskThread<RET>
{
private:
        ARG1 m_arg1;
public:
        TRet1ArgTaskThread(bool ACreateSuspended):TRetNoArgTaskThread<RET>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1)
        {
                SetArg(arg1);
                TTaskThread::RunTask(fun);
        }

protected:
        void SetArg(ARG1 arg1)
        {
                m_arg1=arg1;
        }
        virtual void TaskRun()
        {
                typedef RET (*Ret1Arg)(ARG1);
                Ret1Arg tmp=(Ret1Arg)TRetNoArgTaskThread<RET>::FTaskFun;
                TRetNoArgTaskThread<RET>::ret=tmp(m_arg1);
        }

};

template<class T,class RET,class ARG1,class ARG2>
class TClassRet2ArgTaskThread : public TClassRet1ArgTaskThread<T,RET,ARG1>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
public:
        TClassRet2ArgTaskThread(bool ACreateSuspended):TClassRet1ArgTaskThread<T,RET,ARG1>(ACreateSuspended)
        {
        }
        bool RunTask(RET (T::*fun)(ARG1,ARG2),ARG1 arg1,ARG2 arg2,T t)
        {
                SetArg(arg1,arg2);
                return TClassTaskThread<T>::RunTask((void(T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2)
        {
                m_arg1=arg1;
                m_arg2=arg2;
        }
        virtual void TaskRun()
        {
                typedef RET (T::*Ret2Arg)(ARG1,ARG2);
                Ret2Arg tmp=(Ret2Arg)FTaskFun;
                ret=(m_t.*tmp)(m_arg1,m_arg2);
        }

};

template<class RET,class ARG1,class ARG2>
class TRet2ArgTaskThread : public TRet1ArgTaskThread<RET,ARG1>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
public:
        TRet2ArgTaskThread(bool ACreateSuspended):TRet1ArgTaskThread<RET,ARG1>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2)
        {
                SetArg(arg1,arg2);
                TTaskThread::RunTask(fun);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2)
        {
                m_arg1=arg1;
                m_arg2=arg2;
        }
        virtual void TaskRun()
        {
                typedef RET (*Ret2Arg)(ARG1,ARG2);
                Ret2Arg tmp=(Ret2Arg)TRetNoArgTaskThread<RET>::FTaskFun;
                TRetNoArgTaskThread<RET>::ret=tmp(m_arg1,m_arg2);
        }

};

template<class T,class RET,class ARG1,class ARG2,class ARG3>
class TClassRet3ArgTaskThread : public TClassRet2ArgTaskThread<T,RET,ARG1,ARG2>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
public:
        TClassRet3ArgTaskThread(bool ACreateSuspended):TClassRet2ArgTaskThread<T,RET,ARG1,ARG2>(ACreateSuspended)
        {
        }
        bool RunTask(RET (T::*fun)(ARG1,ARG2,ARG3),ARG1 arg1,ARG2 arg2,ARG3 arg3,T t)
        {
                SetArg(arg1,arg2,arg3);
                return TClassTaskThread<T>::RunTask((void(T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
        }
        virtual void TaskRun()
        {
                typedef RET (T::*Ret3Arg)(ARG1,ARG2,ARG3);
                Ret3Arg tmp=(Ret3Arg)FTaskFun;
                ret=(m_t.*tmp)(m_arg1,m_arg2,m_arg3);
        }

};

template<class RET,class ARG1,class ARG2,class ARG3>
class TRet3ArgTaskThread : public TRet2ArgTaskThread<RET,ARG1,ARG2>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
public:
        TRet3ArgTaskThread(bool ACreateSuspended):TRet2ArgTaskThread<RET,ARG1,ARG2>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3)
        {
                SetArg(arg1,arg2,arg3);
                TTaskThread::RunTask(fun);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
        }
        virtual void TaskRun()
        {
                typedef RET (*Ret3Arg)(ARG1,ARG2,ARG3);
                Ret3Arg tmp=(Ret3Arg)TRetNoArgTaskThread<RET>::FTaskFun;
                TRetNoArgTaskThread<RET>::ret=tmp(m_arg1,m_arg2,m_arg3);
        }

};

template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4>
class TClassRet4ArgTaskThread : public TClassRet3ArgTaskThread<T,RET,ARG1,ARG2,ARG3>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
public:
        TClassRet4ArgTaskThread(bool ACreateSuspended):TClassRet3ArgTaskThread<T,RET,ARG1,ARG2,ARG3>(ACreateSuspended)
        {
        }
        bool RunTask(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,T t)
        {
                SetArg(arg1,arg2,arg3,arg4);
                return TClassTaskThread<T>::RunTask((void(T::*)())fun,t);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
        }
        virtual void TaskRun()
        {
                typedef RET (T::*Ret4Arg)(ARG1,ARG2,ARG3,ARG4);
                Ret4Arg tmp=(Ret4Arg)FTaskFun;
                ret=(m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4);
        }

};

template<class RET,class ARG1,class ARG2,class ARG3,class ARG4>
class TRet4ArgTaskThread : public TRet3ArgTaskThread<RET,ARG1,ARG2,ARG3>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
public:
        TRet4ArgTaskThread(bool ACreateSuspended):TRet3ArgTaskThread<RET,ARG1,ARG2,ARG3>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4)
        {
                SetArg(arg1,arg2,arg3,arg4);
                TTaskThread::RunTask(fun);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
        }
        virtual void TaskRun()
        {
                typedef RET (*Ret4Arg)(ARG1,ARG2,ARG3,ARG4);
                Ret4Arg tmp=(Ret4Arg)TRetNoArgTaskThread<RET>::FTaskFun;
                TRetNoArgTaskThread<RET>::ret=tmp(m_arg1,m_arg2,m_arg3,m_arg4);
        }

};

template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
class TClassRet5ArgTaskThread : public TClassRet4ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
public:
        TClassRet5ArgTaskThread(bool ACreateSuspended):TClassRet4ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4>(ACreateSuspended)
        {
        }
        bool RunTask(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,T t)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5);
                return TClassTaskThread<T>::RunTask((void(T::*)())fun,t);
        }
protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
        }
        virtual void TaskRun()
        {

                typedef RET (T::*Ret5Arg)(ARG1,ARG2,ARG3,ARG4,ARG5);
                Ret5Arg tmp=(Ret5Arg)FTaskFun;
                ret=(m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5);
        }

};

template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
class TRet5ArgTaskThread : public TRet4ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
public:
        TRet5ArgTaskThread(bool ACreateSuspended):TRet4ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5);
                TTaskThread::RunTask(fun);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
        }
        virtual void TaskRun()
        {
                typedef RET (*Ret5Arg)(ARG1,ARG2,ARG3,ARG4,ARG5);
                Ret5Arg tmp=(Ret5Arg)TRetNoArgTaskThread<RET>::FTaskFun;
                TRetNoArgTaskThread<RET>::ret=tmp(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5);
        }

};

template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
class TClassRet6ArgTaskThread : public TClassRet5ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
public:
        TClassRet6ArgTaskThread(bool ACreateSuspended):TClassRet5ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5>(ACreateSuspended)
        {
        }
        bool RunTask(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,T t)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6);
                return TClassTaskThread<T>::RunTask((void(T::*)())fun,t);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
        }
        virtual void TaskRun()
        {
                typedef RET (T::*Ret6Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
                Ret6Arg tmp=(Ret6Arg)FTaskFun;
                ret=(m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6);
        }

};

template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
class TRet6ArgTaskThread : public TRet5ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
public:
        TRet6ArgTaskThread(bool ACreateSuspended):TRet5ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6);
                TTaskThread::RunTask(fun);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
        }
        virtual void TaskRun()
        {
                typedef RET (*Ret6Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
                Ret6Arg tmp=(Ret6Arg)TRetNoArgTaskThread<RET>::FTaskFun;
                TRetNoArgTaskThread<RET>::ret=tmp(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6);
        }

};

template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
class TClassRet7ArgTaskThread : public TClassRet6ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
public:
        TClassRet7ArgTaskThread(bool ACreateSuspended):TClassRet6ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(ACreateSuspended)
        {
        }
        bool RunTask(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,T t)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
                return TClassTaskThread<T>::RunTask((void(T::*)())fun,t);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
        }
        virtual void TaskRun()
        {
                typedef RET (T::*Ret7Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7);
                Ret7Arg tmp=(Ret7Arg)FTaskFun;
                ret=(m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7);
        }

};

template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
class TRet7ArgTaskThread : public TRet6ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
public:
        TRet7ArgTaskThread(bool ACreateSuspended):TRet6ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
                TTaskThread::RunTask(fun);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
        }
        virtual void TaskRun()
        {
                typedef RET (*Ret7Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7);
                Ret7Arg tmp=(Ret7Arg)TRetNoArgTaskThread<RET>::FTaskFun;
                TRetNoArgTaskThread<RET>::ret=tmp(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7);
        }

};

template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
class TClassRet8ArgTaskThread : public TClassRet7ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
        ARG8 m_arg8;
public:
        TClassRet8ArgTaskThread(bool ACreateSuspended):TClassRet7ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(ACreateSuspended)
        {
        }
        bool RunTask(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,T t)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
                return TClassTaskThread<T>::RunTask((void(T::*)())fun,t);
        }

                typedef RET (T::*Ret8Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8);
                Ret8Arg tmp=(Ret8Arg)FTaskFun;
                ret=(m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8);
        }

};

template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
class TRet8ArgTaskThread : public TRet7ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
        ARG8 m_arg8;
public:
        TRet8ArgTaskThread(bool ACreateSuspended):TRet7ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
                TTaskThread::RunTask(fun);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
                m_arg8=arg8;
        }
        virtual void TaskRun()
        {
                typedef RET (*Ret8Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8);
                Ret8Arg tmp=(Ret8Arg)TRetNoArgTaskThread<RET>::FTaskFun;
                TRetNoArgTaskThread<RET>::ret=tmp(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8);
        }

};

template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
class TClassRet9ArgTaskThread : public TClassRet8ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
        ARG8 m_arg8;
        ARG9 m_arg9;
public:
        TClassRet9ArgTaskThread(bool ACreateSuspended):TClassRet8ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(ACreateSuspended)
        {
        }
        bool RunTask(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9,T t)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
                return TClassTaskThread<T>::RunTask((void(T::*)())fun,t);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
                m_arg8=arg8;
                m_arg9=arg9;
        }
        virtual void TaskRun()
        {
                typedef RET (T::*Ret9Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9);
                Ret9Arg tmp=(Ret9Arg)FTaskFun;
                ret=(m_t.*tmp)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8,m_arg9);
        }

};

template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
class TRet9ArgTaskThread : public TRet8ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>
{
private:
        ARG1 m_arg1;
        ARG2 m_arg2;
        ARG3 m_arg3;
        ARG4 m_arg4;
        ARG5 m_arg5;
        ARG6 m_arg6;
        ARG7 m_arg7;
        ARG8 m_arg8;
        ARG9 m_arg9;
public:
        TRet9ArgTaskThread(bool ACreateSuspended):TRet8ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(ACreateSuspended)
        {
        }
        bool RunTask(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9)
        {
                SetArg(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
                TTaskThread::RunTask(fun);
        }

protected:
        void SetArg(ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9)
        {
                m_arg1=arg1;
                m_arg2=arg2;
                m_arg3=arg3;
                m_arg4=arg4;
                m_arg5=arg5;
                m_arg6=arg6;
                m_arg7=arg7;
                m_arg8=arg8;
                m_arg9=arg9;
        }
        virtual void TaskRun()
        {
                typedef RET (*Ret9Arg)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9);
                Ret9Arg tmp=(Ret9Arg)TRetNoArgTaskThread<RET>::FTaskFun;
                TRetNoArgTaskThread<RET>::ret=tmp(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8,m_arg9);
        }

};
//
///
//
enum FunType{
        ftTNoRetNoArgTaskThread,ftTNoRet1ArgTaskThread,ftTNoRet2ArgTaskThread,ftTNoRet3ArgTaskThread,
        ftTNoRet4ArgTaskThread,ftTNoRet5ArgTaskThread,
        ftTRetNoArgTaskThread,ftTRet1ArgTaskThread,ftTRet2ArgTaskThread,ftTRet3ArgTaskThread,
        ftTRet4ArgTaskThread,ftTRet5ArgTaskThread
};
struct QueueNodeInfo
{
//        FunType funtype;
        TTaskThread *taskthread;
        bool runed;
};
struct ClassQueueNodeInfo
{
//        FunType funtype;
        TClassTaskThread<Dummy> *taskthread;
        bool runed;
};

template <class Facet>
class TMutiTaskThread9
{
private:
        vector<QueueNodeInfo> li;
        Facet *mttbf;
public:
        friend class TMutiTaskThread9BatchFacet;
        friend class TMutiTaskThread9ParallelFacet;
        ThreadNotify OnMutiTaskFinished;
        bool WaitForMutiTask()
        {
            //if (mttbf)
            //    mttbf->WaitForTask();
            while (!RunFinished())
                MilliSleep(1);
        }
        TMutiTaskThread9()
        {
            mttbf=NULL;
            OnMutiTaskFinished=NULL;
        }
        ~TMutiTaskThread9()
        {
            ClearTask();
        }
        int AllCount()
        {
            return li.size();
        }
        int RunnedCount()
        {
            int cnt=0;
            for (int i=0;i<li.size();i++)
            {
                if (li[i].runed)
                    cnt++;
            }
            return cnt;
        }

        bool RunFinished()
        {
            return mttbf==NULL;
        }

        bool Start()
        {
            if (li.size()==0)
                return false;
            for (int i=0;i<li.size();i++)
            {
                if (li[i].runed)
                {
                    return false;
                }
            }

            mttbf=new Facet(true,&li,this);
            mttbf->FreeOnTerminate=true;
            mttbf->CancelCreateSuspended();
            return true;
        }
        bool Continue()
        {
            if (typeid(Facet)==typeid(TMutiTaskThread9ParallelFacet))
                return false;
            if (mttbf!=NULL)
                mttbf->pause=false;
            return true;
        }
        bool Pause()
        {
            if (typeid(Facet)==typeid(TMutiTaskThread9ParallelFacet))
                return false;
            if (mttbf!=NULL)
                mttbf->pause=true;
            return true;
        }

        template<class RET>
        RET GetRunedRet(int index)
        {
            TRetNoArgTaskThread<RET>* tmp=dynamic_cast<TRetNoArgTaskThread<RET>* >(li[index].taskthread);
            if (tmp==NULL)
                throw logic_error("It is not TRetNoArgTaskThread class.");
            return tmp->GetReturnValue();
        }

        bool PopFrontTask()
        {
            return DeleteTask(0);
        }
        template<class RET>
        bool PopFrontTask(RET &ret)
        {
            if (li.size()==0)
                return false;
            ret=GetRunedRet<RET>(0);
            DeleteTask(0);
            return true;
        }

        bool DeleteTask(int index)
        {
            if (li.size()==0)
                return false;
            if (!RunFinished()) return false;

            delete li[index].taskthread;
            li.erase(li.begin()+index);
            return true;
        }

        bool ClearTask()
        {
            if (li.size()==0)
                return false;
            if (!RunFinished()) return false;
            for (int i=0;i<li.size();i++)
            {
                    delete li[i].taskthread;
            }
            li.clear();
            return true;
        }

        bool InsertTaskNoRet(int index,void *fun)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TNoRetNoArgTaskThread *taskthread=new TNoRetNoArgTaskThread(true);
                taskthread->RunTask(fun);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;

}

        bool PushBackTaskNoRet(void *fun)
        {
                return InsertTaskNoRet(li.size(),fun);
        }
        template<class ARG1>
        bool InsertTaskNoRet(int index,void *fun,ARG1 arg1)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TNoRet1ArgTaskThread<ARG1> *taskthread=new TNoRet1ArgTaskThread<ARG1>(true);
                taskthread->RunTask(fun,arg1);
                qni.taskthread=taskthre8ad;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;

}

        template<class ARG1>
        bool PushBackTaskNoRet(void *fun,ARG1 arg1)
        {
                return InsertTaskNoRet<ARG1>(li.size(),fun,arg1);
        }

        template<class ARG1,class ARG2>
        bool InsertTaskNoRet(int index,void *fun,ARG1 arg1,ARG2 arg2)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TNoRet2ArgTaskThread<ARG1,ARG2> *taskthread=new TNoRet2ArgTaskThread<ARG1,ARG2>(true);
                taskthread->RunTask(fun,arg1,arg2);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class ARG1,class ARG2>
        bool PushBackTaskNoRet(void *fun,ARG1 arg1,ARG2 arg2)
        {
                return InsertTaskNoRet<ARG1,ARG2>(li.size(),fun,arg1,arg2);
        }

        template<class ARG1,class ARG2,class ARG3>
        bool InsertTaskNoRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TNoRet3ArgTaskThread<ARG1,ARG2,ARG3> *taskthread=new TNoRet3ArgTaskThread<ARG1,ARG2,ARG3>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }

        template<class ARG1,class ARG2,class ARG3>
        bool PushBackTaskNoRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3)
        {
                return InsertTaskNoRet<ARG1,ARG2,ARG3>(li.size(),fun,arg1,arg2,arg3);
        }

        template<class ARG1,class ARG2,class ARG3,class ARG4>
        bool InsertTaskNoRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TNoRet4ArgTaskThread<ARG1,ARG2,ARG3,ARG4> *taskthread=new TNoRet4ArgTaskThread<ARG1,ARG2,ARG3,ARG4>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class ARG1,class ARG2,class ARG3,class ARG4>
        bool PushBackTaskNoRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4)
        {
                return InsertTaskNoRet<ARG1,ARG2,ARG3,ARG4>(li.size(),fun,arg1,arg2,arg3,arg4);
        }

        template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
        bool InsertTaskNoRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TNoRet5ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5> *taskthread=new TNoRet5ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }

        template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
        bool PushBackTaskNoRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5)
        {
                return InsertTaskNoRet<ARG1,ARG2,ARG3,ARG4,ARG5>(li.size(),fun,arg1,arg2,arg3,arg4,arg5);
        }

        template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
        bool InsertTaskNoRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TNoRet6ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6> *taskthread=new TNoRet6ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
        bool PushBackTaskNoRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6)
        {
                return InsertTaskNoRet<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6);
        }

        template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
        bool InsertTaskNoRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TNoRet7ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7> *taskthread=new TNoRet7ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
        bool PushBackTaskNoRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7)
        {
                return InsertTaskNoRet<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7);
        }

        template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
        bool InsertTaskNoRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TNoRet8ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8> *taskthread=new TNoRet8ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
        bool PushBackTaskNoRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8)
        {
                return InsertTaskNoRet<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        }

        template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
        bool InsertTaskNoRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TNoRet9ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9> *taskthread=new TNoRet9ArgTaskThread<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
        bool PushBackTaskNoRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9)
        {
                return InsertTaskNoRet<ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
        }

//
///

        template<class RET>
        bool InsertTaskRet(int index,void *fun)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TRetNoArgTaskThread<RET> *taskthread=new TRetNoArgTaskThread<RET>(true);
                taskthread->RunTask(fun);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;

        }
        template<class RET>
        bool PushBackTaskRet(void *fun)
        {
                return InsertTaskRet<RET>(li.size(),fun);
        }

        template<class RET,class ARG1>
        bool InsertTaskRet(int index,void *fun,ARG1 arg1)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TRet1ArgTaskThread<RET,ARG1> *taskthread=new TRet1ArgTaskThread<RET,ARG1>(true);
                taskthread->RunTask(fun,arg1);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class RET,class ARG1>
        bool PushBackTaskRet(void *fun,ARG1 arg1)
        {
                return InsertTaskRet<RET,ARG1>(li.size(),fun,arg1);
        }

        template<class RET,class ARG1,class ARG2>
        bool InsertTaskRet(int index,void *fun,ARG1 arg1,ARG2 arg2)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TRet2ArgTaskThread<RET,ARG1,ARG2> *taskthread=new TRet2ArgTaskThread<RET,ARG1,ARG2>(true);
                taskthread->RunTask(fun,arg1,arg2);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class RET,class ARG1,class ARG2>
        bool PushBackTaskRet(void *fun,ARG1 arg1,ARG2 arg2)
        {
                return InsertTaskRet<RET,ARG1,ARG2>(li.size(),fun,arg1,arg2);
        }

        template<class RET,class ARG1,class ARG2,class ARG3>
        bool InsertTaskRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TRet3ArgTaskThread<RET,ARG1,ARG2,ARG3> *taskthread=new TRet3ArgTaskThread<RET,ARG1,ARG2,ARG3>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class RET,class ARG1,class ARG2,class ARG3>
        bool PushBackTaskRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3)
        {
                return InsertTaskRet<RET,ARG1,ARG2,ARG3>(li.size(),fun,arg1,arg2,arg3);
        }

        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4>
        bool InsertTaskRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TRet4ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4> *taskthread=new TRet4ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4>
        bool PushBackTaskRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4)
        {
                return InsertTaskRet<RET,ARG1,ARG2,ARG3,ARG4>(li.size(),fun,arg1,arg2,arg3,arg4);
        }

        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
        bool InsertTaskRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TRet5ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5> *taskthread=new TRet5ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
        bool PushBackTaskRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5)
        {
                return InsertTaskRet<RET,ARG1,ARG2,ARG3,ARG4,ARG5>(li.size(),fun,arg1,arg2,arg3,arg4,arg5);
        }

        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
        bool InsertTaskRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TRet6ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6> *taskthread=new TRet6ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
        bool PushBackTaskRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6)
        {
                return InsertTaskRet<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6);
        }

        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
        bool InsertTaskRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TRet7ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7> *taskthread=new TRet7ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
        bool PushBackTaskRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7)
        {
                return InsertTaskRet<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7);
        }

        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
        bool InsertTaskRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TRet8ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8> *taskthread=new TRet8ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
        bool PushBackTaskRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8)
        {
                return InsertTaskRet<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        }

        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
        bool InsertTaskRet(int index,void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9)
        {
                if (!RunFinished()) return false;
                QueueNodeInfo qni;
                TRet9ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9> *taskthread=new TRet9ArgTaskThread<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
                qni.taskthread=taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
        bool PushBackTaskRet(void *fun,ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9)
        {
                return InsertTaskRet<RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
        }

};

class TMutiTaskThread9BatchFacet :public TSimpleThread
{
private:
    vector<QueueNodeInfo> *m_li;
    TMutiTaskThread9<TMutiTaskThread9BatchFacet> *mutitaskthread9;
public:
    bool pause;
    TMutiTaskThread9BatchFacet(bool ACreateSuspended,vector<QueueNodeInfo> *li,TMutiTaskThread9<TMutiTaskThread9BatchFacet> *amutitaskthread9): TSimpleThread(ACreateSuspended)
    {
        m_li=li;
        mutitaskthread9=amutitaskthread9;
        pause=false;
    }
    void WaitForTask()
    {
        while (!mutitaskthread9->RunFinished())
            MilliSleep(1);
    }
    virtual void Execute()
    {

        while (!(*m_li)[m_li->size()-1].runed)
        {
            if (pause==false)
            {
                for (int i=0;i<m_li->size();i++)
                {
                    if (!(*m_li)[i].runed)
                    {
                        (*m_li)[i].taskthread->CancelCreateSuspended();
                        (*m_li)[i].taskthread->InternalWaitForTask();
                        (*m_li)[i].runed=true;
                    }
                }
            }
            if (pause)
                MilliSleep(1);
        }
        if (mutitaskthread9->OnMutiTaskFinished)
            mutitaskthread9->OnMutiTaskFinished(this);
        mutitaskthread9->mttbf=NULL;
    }
};

class TMutiTaskThread9ParallelFacet :public TSimpleThread
{
private:
    vector<QueueNodeInfo> *m_li;
    TMutiTaskThread9<TMutiTaskThread9ParallelFacet> *mutitaskthread9;
public:
    bool pause;
    TMutiTaskThread9ParallelFacet(bool ACreateSuspended,vector<QueueNodeInfo> *li,TMutiTaskThread9<TMutiTaskThread9ParallelFacet> *amutitaskthread9): TSimpleThread(ACreateSuspended)
    {
        m_li=li;
        mutitaskthread9=amutitaskthread9;
        pause=false;
    }
    void WaitForTask()
    {
        while (!mutitaskthread9->RunFinished())
            MilliSleep(1);
    }
    virtual void Execute()
    {

        for (int i=0;i<m_li->size();i++)
        {
            (*m_li)[i].taskthread->CancelCreateSuspended();
        }
        while (mutitaskthread9->RunnedCount()!=mutitaskthread9->AllCount())
        {
            for (int i=0;i<m_li->size();i++)
            {
                if (!(*m_li)[i].runed)
                {
                    bool ret=(*m_li)[i].taskthread->InternalWaitForTaskNoWait();
                    if (ret)
                        (*m_li)[i].runed=true;
                }
            }
            MilliSleep(1);
        }

        if (mutitaskthread9->OnMutiTaskFinished)
            mutitaskthread9->OnMutiTaskFinished(this);
        mutitaskthread9->mttbf=NULL;
    }

};

///&&&&&&&&&&&&&&&&&&&&&&&&&&&&

template <class Facet>
class TClassMutiTaskThread9
{
private:
        vector<ClassQueueNodeInfo> li;
        Facet *mttbf;
public:
        friend class TClassMutiTaskThread9BatchFacet;
        friend class TClassMutiTaskThread9ParallelFacet;
        ThreadNotify OnMutiTaskFinished;
        bool WaitForMutiTask()
        {
            //if (mttbf)
            //    mttbf->WaitForTask();
            while (!RunFinished())
                MilliSleep(1);
        }
        TClassMutiTaskThread9()
        {
            mttbf=NULL;
            OnMutiTaskFinished=NULL;
        }
        ~TClassMutiTaskThread9()
        {
            ClearTask();
        }
        int AllCount()
        {
            return li.size();
        }
        int RunnedCount()
        {
            int cnt=0;
            for (int i=0;i<li.size();i++)
            {
                if (li[i].runed)
                    cnt++;
            }
            return cnt;
        }

        bool RunFinished()
        {
            return mttbf==NULL;
        }

            mttbf=new Facet(true,&li,this);
            mttbf->FreeOnTerminate=true;
            mttbf->CancelCreateSuspended();
            return true;
        }
        bool Continue()
        {
            if (typeid(Facet)==typeid(TClassMutiTaskThread9ParallelFacet))
                return false;
            if (mttbf!=NULL)
                mttbf->pause=false;
            return true;
        }
        bool Pause()
        {
            if (typeid(Facet)==typeid(TClassMutiTaskThread9ParallelFacet))
                return false;
            if (mttbf!=NULL)
                mttbf->pause=true;
            return true;
        }

        template<class T,class RET>
        RET GetRunedRet(int index)
        {
            TClassRetNoArgTaskThread<T,RET>* tmp=dynamic_cast<TClassRetNoArgTaskThread<T,RET>* >(li[index].taskthread);
            if (tmp==NULL)
                throw logic_error("It is not TRetNoArgTaskThread class.");
            return tmp->GetReturnValue();
        }

        bool PopFrontTask()
        {
            return DeleteTask(0);
        }
        template<class T,class RET>
        bool PopFrontTask(RET &ret)
        {
            if (li.size()==0)
                return false;
            ret=GetRunedRet<T,RET>(0);
            DeleteTask(0);
            return true;
        }

        bool DeleteTask(int index)
        {
            if (li.size()==0)
                return false;
            if (!RunFinished()) return false;

            delete li[index].taskthread;
            li.erase(li.begin()+index);
            return true;
        }

        template<class T>
        bool InsertTaskNoRet(int index,void (T::*fun)(),T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassNoRetNoArgTaskThread<T> *taskthread=new TClassNoRetNoArgTaskThread<T>(true);
                taskthread->RunTask(fun,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;

}

        template<class T>
        bool PushBackTaskNoRet(void (T::*fun)(),T t)
        {
                return InsertTaskNoRet<T>(li.size(),fun,t);
        }

        template<class T,class ARG1>
        bool InsertTaskNoRet(int index,void (T::*fun)(ARG1),ARG1 arg1,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassNoRet1ArgTaskThread<T,ARG1> *taskthread=new TClassNoRet1ArgTaskThread<T,ARG1>(true);
                taskthread->RunTask(fun,arg1,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;

}

        template<class T,class ARG1>
        bool PushBackTaskNoRet(void (T::*fun)(ARG1),ARG1 arg1,T t)
        {
                return InsertTaskNoRet<T,ARG1>(li.size(),fun,arg1,t);
        }

        template<class T,class ARG1,class ARG2>
        bool InsertTaskNoRet(int index,void (T::*fun)(ARG1,ARG2),ARG1 arg1,ARG2 arg2,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassNoRet2ArgTaskThread<T,ARG1,ARG2> *taskthread=new TClassNoRet2ArgTaskThread<T,ARG1,ARG2>(true);
                taskthread->RunTask(fun,arg1,arg2,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class ARG1,class ARG2>
        bool PushBackTaskNoRet(void (T::*fun)(ARG1,ARG2),ARG1 arg1,ARG2 arg2,T t)
        {
                return InsertTaskNoRet<T,ARG1,ARG2>(li.size(),fun,arg1,arg2,t);
        }

        template<class T,class ARG1,class ARG2,class ARG3>
        bool InsertTaskNoRet(int index,void (T::*fun)(ARG1,ARG2,ARG3),ARG1 arg1,ARG2 arg2,ARG3 arg3,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassNoRet3ArgTaskThread<T,ARG1,ARG2,ARG3> *taskthread=new TClassNoRet3ArgTaskThread<T,ARG1,ARG2,ARG3>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }

        template<class T,class ARG1,class ARG2,class ARG3>
        bool PushBackTaskNoRet(void (T::*fun)(ARG1,ARG2,ARG3),ARG1 arg1,ARG2 arg2,ARG3 arg3,T t)
        {
                return InsertTaskNoRet<T,ARG1,ARG2,ARG3>(li.size(),fun,arg1,arg2,arg3,t);
        }

        template<class T,class ARG1,class ARG2,class ARG3,class ARG4>
        bool InsertTaskNoRet(int index,void (T::*fun)(ARG1,ARG2,ARG3,ARG4),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassNoRet4ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4> *taskthread=new TClassNoRet4ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }

        template<class T,class ARG1,class ARG2,class ARG3,class ARG4>
        bool PushBackTaskNoRet(void (T::*fun)(ARG1,ARG2,ARG3,ARG4),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,T t)
        {
                return InsertTaskNoRet<T,ARG1,ARG2,ARG3,ARG4>(li.size(),fun,arg1,arg2,arg3,arg4,t);
        }

        template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
        bool InsertTaskNoRet(int index,void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassNoRet5ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5> *taskthread=new TClassNoRet5ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }

        template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
        bool PushBackTaskNoRet(void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,T t)
        {
                return InsertTaskNoRet<T,ARG1,ARG2,ARG3,ARG4,ARG5>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,t);
        }

        template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
        bool InsertTaskNoRet(int index,void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassNoRet6ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6> *taskthread=new TClassNoRet6ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
        bool PushBackTaskNoRet(void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,T t)
        {
                return InsertTaskNoRet<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,t);
        }

        template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
        bool InsertTaskNoRet(int index,void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassNoRet7ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7> *taskthread=new TClassNoRet7ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
        bool PushBackTaskNoRet(void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,T t)
        {
                return InsertTaskNoRet<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,t);
        }

        template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
        bool InsertTaskNoRet(int index,void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassNoRet8ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8> *taskthread=new TClassNoRet8ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
        bool PushBackTaskNoRet(void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,T t)
        {
                return InsertTaskNoRet<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,t);
        }

        template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
        bool InsertTaskNoRet(int index,void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassNoRet9ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9> *taskthread=new TClassNoRet9ArgTaskThread<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
        bool PushBackTaskNoRet(void (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9,T t)
        {
                return InsertTaskNoRet<T,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,t);
        }

//
///

        template<class T,class RET>
        bool InsertTaskRet(int index,RET (T::*fun)(),T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassRetNoArgTaskThread<T,RET> *taskthread=new TClassRetNoArgTaskThread<T,RET>(true);
                taskthread->RunTask(fun,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;

        }
        template<class T,class RET>
        bool PushBackTaskRet(RET (T::*fun)(),T t)
        {
                return InsertTaskRet<T,RET>(li.size(),fun,t);
        }

        template<class T,class RET,class ARG1>
        bool InsertTaskRet(int index,RET (T::*fun)(ARG1),ARG1 arg1,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassRet1ArgTaskThread<T,RET,ARG1> *taskthread=new TClassRet1ArgTaskThread<T,RET,ARG1>(true);
                taskthread->RunTask(fun,arg1,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class RET,class ARG1>
        bool PushBackTaskRet(RET (T::*fun)(ARG1),ARG1 arg1,T t)
        {
                return InsertTaskRet<T,RET,ARG1>(li.size(),fun,arg1,t);
        }

        template<class T,class RET,class ARG1,class ARG2>
        bool InsertTaskRet(int index,RET (T::*fun)(ARG1,ARG2),ARG1 arg1,ARG2 arg2,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassRet2ArgTaskThread<T,RET,ARG1,ARG2> *taskthread=new TClassRet2ArgTaskThread<T,RET,ARG1,ARG2>(true);
                taskthread->RunTask(fun,arg1,arg2,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class RET,class ARG1,class ARG2>
        bool PushBackTaskRet(RET (T::*fun)(ARG1,ARG2),ARG1 arg1,ARG2 arg2,T t)
        {
                return InsertTaskRet<T,RET,ARG1,ARG2>(li.size(),fun,arg1,arg2,t);
        }

        template<class T,class RET,class ARG1,class ARG2,class ARG3>
        bool InsertTaskRet(int index,RET (T::*fun)(ARG1,ARG2,ARG3),ARG1 arg1,ARG2 arg2,ARG3 arg3,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassRet3ArgTaskThread<T,RET,ARG1,ARG2,ARG3> *taskthread=new TClassRet3ArgTaskThread<T,RET,ARG1,ARG2,ARG3>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class RET,class ARG1,class ARG2,class ARG3>
        bool PushBackTaskRet(RET (T::*fun)(ARG1,ARG2,ARG3),ARG1 arg1,ARG2 arg2,ARG3 arg3,T t)
        {
                return InsertTaskRet<T,RET,ARG1,ARG2,ARG3>(li.size(),fun,arg1,arg2,arg3,t);
        }

        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4>
        bool InsertTaskRet(int index,RET (T::*fun)(ARG1,ARG2,ARG3,ARG4),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,T t)
        {                   sdsdsd
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassRet4ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4> *taskthread=new TClassRet4ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4>
        bool PushBackTaskRet(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,T t)
        {
                return InsertTaskRet<T,RET,ARG1,ARG2,ARG3,ARG4>(li.size(),fun,arg1,arg2,arg3,arg4,t);
        }

        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
        bool InsertTaskRet(int index,RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassRet5ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5> *taskthread=new TClassRet5ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5>
        bool PushBackTaskRet(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,T t)
        {
                return InsertTaskRet<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,t);
        }

        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
        bool InsertTaskRet(int index,RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassRet6ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6> *taskthread=new TClassRet6ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6>
        bool PushBackTaskRet(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,T t)
        {
                return InsertTaskRet<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,t);
        }

        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
        bool InsertTaskRet(int index,RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassRet7ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7> *taskthread=new TClassRet7ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7>
        bool PushBackTaskRet(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,T t)
        {
                return InsertTaskRet<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,t);
        }

        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
        bool InsertTaskRet(int index,RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassRet8ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8> *taskthread=new TClassRet8ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8>
        bool PushBackTaskRet(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,T t)
        {
                return InsertTaskRet<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,t);
        }

        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
        bool InsertTaskRet(int index,RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9,T t)
        {
                if (!RunFinished()) return false;
                ClassQueueNodeInfo qni;
                TClassRet9ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9> *taskthread=new TClassRet9ArgTaskThread<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9>(true);
                taskthread->RunTask(fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,t);
                qni.taskthread=(TClassTaskThread<Dummy> *)taskthread;
                qni.runed=false;
                li.insert(li.begin()+index,qni);
                return true;
        }
        template<class T,class RET,class ARG1,class ARG2,class ARG3,class ARG4,class ARG5,class ARG6,class ARG7,class ARG8,class ARG9>
        bool PushBackTaskRet(RET (T::*fun)(ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9),ARG1 arg1,ARG2 arg2,ARG3 arg3,ARG4 arg4,ARG5 arg5,ARG6 arg6,ARG7 arg7,ARG8 arg8,ARG9 arg9,T t)
        {
                return InsertTaskRet<T,RET,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7,ARG8,ARG9>(li.size(),fun,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,t);
        }

};

class TClassMutiTaskThread9BatchFacet :public TSimpleThread
{
private:
    vector<ClassQueueNodeInfo> *m_li;
    TClassMutiTaskThread9<TClassMutiTaskThread9BatchFacet> *mutitaskthread9;
public:
    bool pause;
    TClassMutiTaskThread9BatchFacet(bool ACreateSuspended,vector<ClassQueueNodeInfo> *li,TClassMutiTaskThread9<TClassMutiTaskThread9BatchFacet> *amutitaskthread9): TSimpleThread(ACreateSuspended)
    {
        m_li=li;
        mutitaskthread9=amutitaskthread9;
        pause=false;
    }
    void WaitForTask()
    {
        while (!mutitaskthread9->RunFinished())
            MilliSleep(1);
    }
    virtual void Execute()
    {

class TClassMutiTaskThread9ParallelFacet :public TSimpleThread
{
private:
    vector<ClassQueueNodeInfo> *m_li;
    TClassMutiTaskThread9<TClassMutiTaskThread9ParallelFacet> *mutitaskthread9;
public:
    bool pause;
    TClassMutiTaskThread9ParallelFacet(bool ACreateSuspended,vector<ClassQueueNodeInfo> *li,TClassMutiTaskThread9<TClassMutiTaskThread9ParallelFacet> *amutitaskthread9): TSimpleThread(ACreateSuspended)
    {
        m_li=li;
        mutitaskthread9=amutitaskthread9;
        pause=false;
    }
    void WaitForTask()
    {
        while (!mutitaskthread9->RunFinished())
            MilliSleep(1);
    }
    virtual void Execute()
    {

        if (mutitaskthread9->OnMutiTaskFinished)
            mutitaskthread9->OnMutiTaskFinished(this);
        mutitaskthread9->mttbf=NULL;
    }

};

///&&&&&&&&&&&&&&&&&&&&&&&&&&&&

typedef TMutiTaskThread9<TMutiTaskThread9BatchFacet> TBatchTaskThreads;
typedef TMutiTaskThread9<TMutiTaskThread9ParallelFacet> TParallelTaskThreads;
typedef TClassMutiTaskThread9<TClassMutiTaskThread9BatchFacet> TClassBatchTaskThreads;
typedef TClassMutiTaskThread9<TClassMutiTaskThread9ParallelFacet> TClassParallelTaskThreads;

}
//---------------------------------------------------------------------------
#endif

superyys

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
TaskThread类库简介

近日灵感飙升，突发奇想,模拟操作系统调度进程的方式写了个调度函数的类库，暂称为TaskThread,此类皆组合或继承自TTaskThread类，它们是一种奇妙的类，它们可以把一个一个的现成函数当成一个“process"强行塞入TaskThread的线程运行，用户不再需要额外初始化线程类。本函数库甚至能模拟操作系统的方式对“任务函数”进行调度运行，目前的策略支持批处理和并行模式，类似OS的批
复制链接

扫一扫