{
   CSomeRunnable work;
   CThreadPool pool;
   pool.Init();
   pool.Start(&work);
   pool.Shutdown();
}

class CSomeRunable : public IRunable
{
   virtual void Run() 
   {
      // execute any work

      delete this;
   }
};

{
   pool.Start(new CSomeRunnable());
}

class Thread
{
    // thread_xxxxx - функции, исполняемые в контексте потока
    
    // интерфейс от потомков
    virtual void thread_prolog() throw();
    virtual void thread_body();
    virtual void thread_epilog() throw();
    
    void thread_outline()
    {
        // пролог-эпилог можно завернуть в scope guard
        thread_prolog();
        try
        {
            thread_notify_started();
            thread_body();
        }
        catch(StopSignal)
        {
        }
        catch(...)
        {
        }
        thread_epilog();
    }
    
    Handle m_thrSlave;
    static int thread_thunk(void* p)
    {
        static_cast<Thread*>(p)->thread_outline();
        return 0;
    }

    volatile bool m_resume, m_stop;
    Event m_evtMaster, m_evtSlave;
    
    void thread_notify_started()
    {
        m_evtSlave.set();
        while(true)
        {
            thread_check();
            if(m_resume)
                break;
            m_evtMaster.wait(INFINITE);
        }
    }
    
    void thread_check()
    {
        if(m_stop)
            throw StopSignal;
    }
public:
    void start(bool resumed)
    {
        m_thrSlave = begin_thread(thread_thunk, this);
        m_evtSlave.wait(INFINITE);
        
        if(resumed)
            resume();
    }
    void resume()
    {
        m_resume = resumed;
        m_evtMaster.set();
    }
    void stop(int timeout)
    {
        m_stop = true;
        if(m_thrSlave)
            m_thrSlave.wait(timeout);
    }
};

class SharedThread
{
    weak_ptr<SharedThread> m_weakMyself;
    shared_ptr<SharedThread> m_strongMyself; // владеет собой внутри потока
    
    void thread_prolog() { m_strongMyself = myself(); }
    void thread_epilog() { m_strongMyself.reset(); }

public:
    SharedThread() : m_weakMyself(this) {}
    shared_ptr<SharedThread> myself() { return m_weakMyself; }
};

.....
shared_ptr<SharedThread> p (new MySharedThread().myself());
p->start(true);
p.reset();
.....

class IRunable
{
public:
    virtual void Run() = 0;
    virtual ~IRunable();
};

void Start(IRunable* _pcRunable); // < запускает метод Run() _pcRunable в отдельном потоке.

class CSomeRunable : public IRunable
{
    virtual void Run(); // < Код пользователя, запускаемый в отдельном потоке.
    void AdditionalMethod();
};

int main()
{
    CSomeRunable* p = new CSomeRunable();
    Start(p); // < Запуск  CSomeRunable::Run() в отдельной нити.

    // ....

    p->AdditionalMethod();

    // ....

    delete p; /// Некорректно! Нет гарантии что объект не используется другой нитью.
    
    return 0;
}

class IRunable
{
public:
    virtual void Run() = 0;
    virtual IRunable* Сlone() = 0; // < Создаёт копию объекта
    virtual ~IRunable() ;
};

void Start(const IRunable& _rcRunable); // < Создаёт копию _rcRunable и запускает метод Run() копии в отдельном потоке.
                                        // По завершении Run(), копия удаляется.

int main()
{
    CSomeRunable p;
    Start(&p);
}

Alu>Недостатки: необъектно и подедовски

class BaseThread
{

static unsigned int __stdcall StaticThreadRoutine(void*p)
{
 ((BaseThread*)p)->ThreadRoutine();
 return 0;
}

protected:
//overload in descedant
virtual void ThreadRoutine() = 0;

//use in descedant's code
virtual bool IsCheckStopped(DWORD wait = 0) {return ::WaitForSingleObject(_stop, wait)==WAIT_OBJECT_0;}

//don't publish in descedants
virtual ~BaseThread()
{
 assert(_thread==NULL);
 if (_stop) ::CloseHandle(_stop);
}

//start object's thread
void Start()
{
assert(!_thread);
if (!_stop) _stop = ::CreateEvent(0, 1, 0, 0); else ::ResetEvent(_stop);
_thread = (HANDLE)_beginthreadex(..., StatisThreadRoutine, this, ...);
}

//stop object's thread
void Stop()
{
assert(_thread && _stop);
::SetEvent(_stop);
::WaitForSingleObject(_thread, INFINITE);
::CloseHandle(_thread);
_thread = NULL;
}

public:

//use to delete object instance
virtual void Release()
{
if (_thread) Stop();
delete this;
}

void Activate()
{
if (!_thread) Start();
}

};

Alu>class IRunable
Alu>{
Alu>public:
Alu>    virtual void Run() = 0;
Alu>    virtual ~IRunable();
Alu>};
Alu>

class IRunable
{
public:
    virtual void Run() = 0;
    virtual IRunable* Clone() = 0;
    virtual ~IRunable();
};

void Start(IRunable* _pcRunable)
{
    // Теперь у нас есть копия, за временем жизни которой мы можем управлять.
    IRunable* pRunable = _pcRunable->Clone();
    // ... 
}

struct iThread
{
     void run()
     {
          <start-thread-proc>( &iThread::start, this );
     }

protected:
     static void start(iThread* src) 
     {   
         std::auto_ptr<iWork> me( src );
         me->do_run();         
     } 

     virtual void do_run() = 0;
};

struct Thread : iThread
{
   do_run(){...}
};

Thread* thread = new Thread();
thread->run();