Linux thread 封装实现

头文件duye_thread.h

/************************************************************************************
**  
* @copyright (c) 2013-2100,  Technology Co., LTD. All Right Reserved.
*
*************************************************************************************/
/**
* @file	    duye_thread.h
* @version     
* @brief      
* @autho    duye
* @date	    2013-11-26
* @note 
*
* 2. 2014-01-12 duye Add comments   
* 1. 2013-11-26 Created this file
* 
*/
#pragma once

#include <pthread.h> 
#include <duye_type.h>

namespace duye {
	
/** 
 * @brief thread state
 */
typedef enum {
    /** 
     * @brief running state
     */	
    THR_STATE_RUN = 0,
    /** 
     * @brief stoped state
     */		
    THR_STATE_STOP,
    /** 
     * @brief exit state
     */		
    THR_STATE_EXIT
} ThreadState;

/** 
 * @brief the pointer of thread enter
 */
typedef void* (*ThreadFunPoint)(void*);

/** 
 * @brief be inherited ty user
 */
class Runnable {
public:
    virtual ~Runnable() {}

    /**
     * @brief user thread entry function
     * @return true/false
     * @note 
     */			
    virtual bool run() = 0;
};

/** 
 * @brief POSIX thread wrapper
 */
class Thread {
public:    
    /**
     * @brief constructor
     * @param [in] target : user run target object
     * @param [in] autoRel : whether support automatic release, default is yes
     * @note 
     */		
    explicit Thread(const bool autoRel = true);
    explicit Thread(Runnable* target, const bool autoRel = true);
    ~Thread();

    /**
     * @brief startup thread
     * @return true/false
     * @note 
     */		
    bool start();
    bool start(Runnable* target, const bool autoRel = true);
    
    /**
     * @brief join thread
     */
    bool join();
    
    /**
     * @brief exit thread
     */
    void exit();

    /**
     * @brief get thread ID
     * @return thread ID
     * @note 
     */		
    uint64 threadId() const;

private:
    Thread(const Thread&);
    void operator=(const Thread&);
    static void* enterPoint(void* argument);

private: 
    // thread ID
    pthread_t    m_threadId;
    // indicate whether is detached with main thread default is detached
    bool         m_autoRel;
    // user thread object
    Runnable*	 m_runnable;
};

/** 
 * @brief thread base class, be inherited by user
 */
class ThreadTask : public Runnable {
public:
    /**
     * @brief constructor
     * @para [in] autoRel : whether is detached with main thread, default is detached
     * @note 
     */		
    explicit ThreadTask(const bool autoRel = true);
    virtual ~ThreadTask();
  
    /**
     * @brief startup thread
     * @param [in] autoRel : whether is detached from main thread, default is detached
     * @return true/false
     * @note 
     */		
    bool startTask(const bool autoRel = true);
    
    /**
     * @brief join
     * @return true/false
     */
    bool join();

    /**
     * @brief get thread ID
     * @return thread ID
     */		
    uint64 threadId() const;

    /**
     * @brief thread entry function
     * @return true/false
     * @note 
     */			
    virtual bool run() = 0;

private:
    // brief : prevate copying
    ThreadTask(const ThreadTask&);
    void operator=(const ThreadTask&);

private:
    Thread m_thread;	
    // whether is detached with main thread, default is ture, 
    // indicate detached with main thread
    bool   m_autoRel;
};

/** 
 * @brief POSIX thread static API used outside
 */
class ThreadUtil {
public:
    /**
     * @brief create thread
     * @param [in] entry : thread entry fucntion pointer
     * @param [in] argument : user data
     * @param [in] autoRel : whether support automatic release, default is yes
     * @return thread ID / -1
     * @note 
     */		
    static int32 createThread(void* entry, void* argument, const bool autoRel = true);
};

}

cpp文件duye_thread.cpp

/************************************************************************************
**  
* @copyright (c) 2013-2100,  Technology Co., LTD. All Right Reserved.
*
*************************************************************************************/
/**
* @file	    duye_thread.cpp
* @version     
* @brief      
* @author
* @date	    2013-11-26
* @note 
*
*  1. 2013-11-26 Created this file
* 
*/
#include <stdio.h>
#include <duye_thread.h> 

namespace duye {

Thread::Thread(const bool autoRel) 
    : m_threadId(0)
    , m_autoRel(autoRel)
    , m_runnable(NULL) {}
    
Thread::Thread(Runnable* runnable, const bool autoRel) 
    : m_threadId(0)
    , m_autoRel(autoRel)
    , m_runnable(runnable) {}

Thread::~Thread() {}

bool Thread::start() {
    pthread_attr_t* attributes = NULL;
    bool ret = pthread_create(&m_threadId, attributes, enterPoint, m_runnable);
    if (ret != 0) {
    	return false;
    }

    if (m_autoRel) {
    	pthread_detach(m_threadId);
    }

    return true;
}

bool Thread::start(Runnable* target, const bool autoRel) {
    m_runnable = target;
    m_autoRel = autoRel;
    return start();
}

bool Thread::join() {
    return pthread_join(m_threadId, NULL) == 0 ? true : false;
}

void Thread::exit() {
    pthread_exit(NULL);
}   

uint64 Thread::threadId() const {
    return (uint64)pthread_self();
}

void* Thread::enterPoint(void* argument) {
    Runnable* runnable = static_cast<Runnable*>(argument);
    runnable->run();
    return NULL;
}

ThreadTask::ThreadTask(const bool autoRel) : m_autoRel(autoRel) {}

ThreadTask::~ThreadTask() {}

bool ThreadTask::startTask(const bool autoRel) {
    return m_thread.start(this, autoRel);
}

bool ThreadTask::join() {
   return m_thread.join();   
}

uint64 ThreadTask::threadId() const {
	return m_thread.threadId();
}

int32 ThreadUtil::createThread(void* entry, void* argument, const bool autoRel) {
    pthread_attr_t* attributes = NULL;
    pthread_t threadId = -1;

    int32 ret = pthread_create(&threadId, attributes, (ThreadFunPoint)entry, argument);
    if (ret != 0) {
    	return (int32)threadId;
    }

    if (autoRel) {
    	pthread_detach(threadId);
    }

    return (int32)threadId;
}

}

开源地址：https://gitee.com/DuyeOpen/Venus