C++线程类的封装

简单的C++线程操作的封装，使用了智能指针管理对象的释放。

可运行对象基类

class SimpleRunable:public RefCountedBase
{
public:
    SimpleRunable(){}
    virtual ~SimpleRunable(){}//必须为虚析构函数否则，子类析构函数无法调用
    virtual void OnRun()=0;//由线程调用
};

实现SimpleRunable的OnRun就可以交由SimpleThread运行。

 

多线程类封装

class SimpleThread
{
public:
    SimpleThread(void);
    ~SimpleThread(void);

    bool Start(RefCountedPtr<SimpleRunable> runable);//创建线程
    bool Stop();        //强制关闭线程,不建议使用
    bool IsRunning();    //判断是否运行

    RefCountedPtr<SimpleRunable> GetRunable();//获取当前可运行任务
    HANDLE GetHandle();    //获取线程句柄
    DWORD GetId();        //  获取线程id
private:
    //禁止赋值构造
    SimpleThread(const SimpleThread&);
    const SimpleThread& operator=(const SimpleThread&);

    static void ThreadProc(void* param);
    struct ThreadData* m_data;
};

使用方法如下：

class TestRunable:public SimpleRunable
{
public:
    void OnRun()
    {
        for( int i=0;i<100;++i)
        {
            printf("t%d\t",i);
        }
    }
    ~TestRunable()
    {
        printf("destroy TestRunable\n");
    }
};

static void TestSimpleThread()
{
    SimpleThread thread;
    CountedPtr<SimpleRunable> runable(new TestRunable);
    thread.Start(runable);Sleep(100);
}

SimpleThread类的实现如下：

struct ThreadData
{
    ThreadData():m_isRunning(false),m_handle(NULL),m_count(1)//m_count默认值为1,由SimpleThread所拥有
    {}
    ~ThreadData()
    {
    }
    bool m_isRunning;
    HANDLE m_handle;

    int m_count;//计数
    RefCountedPtr<SimpleRunable> m_runable;
};


SimpleThread::SimpleThread(void):m_data(new ThreadData)
{
}


SimpleThread::~SimpleThread(void)
{
    if (AtomicOps::Decrement(&m_data->m_count)==0)
    {
        delete m_data;
    }
}


bool SimpleThread::Start(RefCountedPtr<SimpleRunable> runable)
{
    //如果正在运行返回false
    if (m_data->m_isRunning)
    {
        return false;
    }

    m_data->m_runable=runable;
    AtomicOps::Increment(&m_data->m_count);//该计数由ThreadProc减1

    HANDLE handle=(HANDLE)_beginthread(ThreadProc,0,m_data);
    m_data->m_handle=handle;
    if (!handle)
    {
        AtomicOps::Decrement(&m_data->m_count);//线程创建失败计数减一
        return false;
    }
    else
    {
        m_data->m_isRunning=true;
        return true;
    }
}

bool SimpleThread::IsRunning()
{
    return m_data->m_isRunning;
}


RefCountedPtr<SimpleRunable> SimpleThread::GetRunable()
{
    return m_data->m_runable;
}

HANDLE SimpleThread::GetHandle()
{
    if (IsRunning())
        return m_data->m_handle;
    else
        return NULL;
}

DWORD SimpleThread::GetId()
{
    HANDLE handle=GetHandle();
    if(handle)
        return GetThreadId(handle);
    else
        return 0;
}


bool SimpleThread::Stop()
{
    if (m_data->m_isRunning)
    {
        return CloseHandle(m_data->m_handle)==TRUE;
    }
    else
        return false;
}



void SimpleThread::ThreadProc(void* param)
{
    ThreadData* data=(ThreadData*)param;


    RefCountedPtr<SimpleRunable>& runable=data->m_runable;
    if (runable)
    {
        runable->OnRun();
    }


    data->m_isRunning=false;
    if(AtomicOps::Decrement(&data->m_count)==0)
        delete data;
    _endthread();
}

 

 

 

转载于:https://www.cnblogs.com/zentel/p/3722525.html