Linux学习之线程封装七：基于接口的再封装

在“Linux学习之线程封装五：基于接口的封装”的基础上，增加了协调器类“CLCoordinator”。

业务逻辑提供者类“CLCoordinator”，与“五”一样。

执行体类“CLExecutive”，将类的和构造函数的CLExecutiveFunctionProvider类型成员换成了CLCoordinator类型，其余都一样。

重点看下新增的协调器类“CLCoordinator”(抽象类)

头文件：

#ifndef CLCoordinator_H
#define CLCoordinator_H

#include "CLStatus.h"

class CLExecutive;
class CLExecutiveFunctionProvider;

class CLCoordinator
{
public:
    CLCoordinator();
    virtual ~CLCoordinator();

    void SetExecObjects(CLExecutive *pExecutive, CLExecutiveFunctionProvider *pProvider);

    virtual CLStatus Run(void *pContext) = 0;
    virtual CLStatus ReturnControlRights() = 0;
    virtual CLStatus WaitForDeath() = 0;

private:
    CLCoordinator(const CLCoordinator&);
    CLCoordinator& operator=(const CLCoordinator&);

protected:
    CLExecutive *m_pExecutive;
    CLExecutiveFunctionProvider *m_pExecutiveFunctionProvider;
};

#endif

实现文件：

#include "CLCoordinator.h"

CLCoordinator::CLCoordinator()
{
}

CLCoordinator::~CLCoordinator()
{
}

void CLCoordinator::SetExecObjects(CLExecutive *pExecutive, CLExecutiveFunctionProvider *pProvider)
{
    m_pExecutive = pExecutive;
    m_pExecutiveFunctionProvider = pProvider;
}

Run()和WaitForDeath()比较简单，不管执行体是什么(进程或线程)，最终都应该调用执行类的相关函数。

着重说一下ReturnControlRights(),在“五”中，我们的执行体直接参与了业务逻辑的装配；然而，实际情况是，它只要负责实际业务逻辑的并返回状态就可以了，至于业务逻辑是谁，它并不需要知道。为此，我们增加了协调器类，它使执行体可以专注于执行，从而与具体业务逻辑彻底分开；同时，又可以对执行体的运行进行控制(例如延迟运行)，进行业务逻辑的装配。这正是“协调“的意义。ReturnControlRights()在本例中只是简单的调用了具体的业务逻辑。

协调器(例)"CLRegularCoordinator"

头文件：

#ifndef CLRegularCoordinator_H
#define CLRegularCoordinator_H

#include "CLCoordinator.h"

class CLRegularCoordinator : public CLCoordinator
{
public:
    CLRegularCoordinator();
    virtual ~CLRegularCoordinator();

    virtual CLStatus Run(void *pContext);
    virtual CLStatus ReturnControlRights();
    virtual CLStatus WaitForDeath();

private:
    CLRegularCoordinator(const CLRegularCoordinator&);
    CLRegularCoordinator& operator=(const CLRegularCoordinator&);

private:
    void *m_pContext;
};

#endif

实现：

#include "CLRegularCoordinator.h"
#include "CLExecutiveFunctionProvider.h"
#include "CLExecutive.h"

CLRegularCoordinator::CLRegularCoordinator()
{
}

CLRegularCoordinator::~CLRegularCoordinator()
{
}

CLStatus CLRegularCoordinator::Run(void *pContext)
{
    if((m_pExecutive == 0) || (m_pExecutiveFunctionProvider == 0))
        return CLStatus(-1, 0);

    m_pContext = pContext;

    return m_pExecutive->Run();
}

CLStatus CLRegularCoordinator::ReturnControlRights()
{
    return m_pExecutiveFunctionProvider->RunExecutiveFunction(m_pContext);
}

CLStatus CLRegularCoordinator::WaitForDeath()
{
    return m_pExecutive->WaitForDeath();
}

执行体(例：线程)"CLThread"

头文件：

#ifndef CLTHREAD_H
#define CLTHREAD_H

#include <pthread.h>
#include "CLExecutive.h"
#include "CLStatus.h"

class CLThread : public CLExecutive
{
public:
    explicit CLThread(CLCoordinator *pCoordinator);
    virtual ~CLThread();

    virtual CLStatus Run();

    virtual CLStatus WaitForDeath();

private:
    static void* StartFunctionOfThread(void *pContext);

private:
    pthread_t m_ThreadID; 
};

#endif

实现：

#include "CLThread.h"
#include "CLCoordinator.h"
#include "CLLog.h"

CLThread::CLThread(CLCoordinator *pCoordinator) : CLExecutive(pCoordinator)
{
}

CLThread::~CLThread()
{
}

CLStatus CLThread::Run()
{    
    int r = pthread_create(&m_ThreadID, 0, StartFunctionOfThread, this);
    if(r != 0)
    {
        CLLog::WriteLogMsg("In CLThread::Run(), pthread_create error", r);
        return CLStatus(-1, 0);
    }

    return CLStatus(0, 0);
}

void* CLThread::StartFunctionOfThread(void *pThis)
{
    CLThread *pThreadThis = (CLThread *)pThis;

    pThreadThis->m_pCoordinator->ReturnControlRights();

    return 0;
}

CLStatus CLThread::WaitForDeath()
{
    int r = pthread_join(m_ThreadID, 0);
    if(r != 0)
    {
        CLLog::WriteLogMsg("In CLThread::WaitForDeath(), pthread_join error", r);
        return CLStatus(-1, 0);
    }

    return CLStatus(0, 0);
}

调用：

#include <iostream>
#include "CLExecutiveFunctionProvider.h"
#include "CLThread.h"
#include "CLRegularCoordinator.h"

using namespace std;

class CLMyPrinter : public CLExecutiveFunctionProvider
{
public:
    CLMyPrinter(){}
    ~CLMyPrinter(){}
    
    virtual CLStatus RunExecutiveFunction(void* pContext)
    {
        int i = (int)pContext;
        cout << i << endl;
        return CLStatus(0, 0);
    }    
};

int main()
{
    CLCoordinator *pCoordinator =  new CLRegularCoordinator();
    CLExecutive *pExecutive = new CLThread(pCoordinator);
    CLExecutiveFunctionProvider *pProvider = new CLMyPrinter();

    pCoordinator->SetExecObjects(pExecutive, pProvider);

    pCoordinator->Run((void *)5);

    pCoordinator->WaitForDeath();

    return 0;
}

注意：在执行体类及其子类(CLThread)的构造函数中都使用了explicit关键字，而在main()中，无一例外的使用了"基类指针 变量名=new 子类()"的形式。